@miclivs/cadcli 0.1.1 → 0.2.0

package/dist/core/acad-edit.js

@@ -0,0 +1,234 @@
+import { Arc, Circle, Color, Insert, Layer, Line, LineType, LineWeightType, LwPolyline, MText, Point, TextEntity, Transparency, XY, XYZ, } from "@node-projects/acad-ts";
+import { EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { readAcadFile, writeAcadDocument } from "./acad.js";
+import { DwgCliError } from "./errors.js";
+import { writeOutput } from "./files.js";
+const degreesToRadians = (degrees) => (degrees * Math.PI) / 180;
+function xyz(point) {
+    return new XYZ(point.x, point.y, point.z ?? 0);
+}
+function xy(point) {
+    return new XY(point.x, point.y);
+}
+function handleMatches(handle, entityId) {
+    const expected = entityId.toLowerCase();
+    const text = String(handle ?? "").toLowerCase();
+    if (text === expected)
+        return true;
+    const numeric = Number(handle);
+    return (Number.isFinite(numeric) && numeric.toString(16).toLowerCase() === expected);
+}
+function modelEntities(doc) {
+    return [...(doc.modelSpace?.entities ?? [])];
+}
+function findEntity(doc, entityId) {
+    const entity = modelEntities(doc).find((item) => handleMatches(item.handle, entityId));
+    if (!entity) {
+        throw new DwgCliError(`Entity not found: ${entityId}`, "ENTITY_NOT_FOUND", EXIT_USER_ERROR);
+    }
+    return entity;
+}
+function ensureLayer(doc, name) {
+    const existing = doc.layers?.tryGetValue(name);
+    if (existing)
+        return existing;
+    const layer = new Layer(name);
+    doc.layers?.add(layer);
+    return layer;
+}
+function ensureLineType(doc, name) {
+    const existing = doc.lineTypes?.tryGetValue(name);
+    if (existing)
+        return existing;
+    const lineType = new LineType(name);
+    doc.lineTypes?.add(lineType);
+    return lineType;
+}
+function acadColor(color) {
+    switch (color.mode) {
+        case "byLayer":
+            return Color.byLayer;
+        case "byBlock":
+            return Color.byBlock;
+        case "index":
+            return new Color(color.index);
+        case "rgb":
+            return new Color(color.r, color.g, color.b);
+    }
+}
+function lineWeight(weight) {
+    if (!Object.values(LineWeightType).includes(weight)) {
+        throw new DwgCliError(`Unsupported line weight: ${weight}`, "INVALID_LINE_WEIGHT", EXIT_USER_ERROR);
+    }
+    return weight;
+}
+function applyCommonOptions(doc, entity, options) {
+    if (options.layer)
+        entity.layer = ensureLayer(doc, options.layer);
+    if (options.color)
+        entity.color = acadColor(options.color);
+}
+function addEntity(doc, entity) {
+    if (!doc.modelSpace) {
+        throw new DwgCliError("Drawing has no model space to edit.", "MODEL_SPACE_NOT_FOUND", EXIT_USER_ERROR);
+    }
+    doc.modelSpace.entities.add(entity);
+}
+function deleteEntity(entity, entityId) {
+    const owner = entity.owner;
+    if (!owner?.entities?.remove) {
+        throw new DwgCliError(`Entity cannot be deleted: ${entityId}`, "ENTITY_NOT_DELETABLE", EXIT_USER_ERROR);
+    }
+    owner.entities.remove(entity);
+}
+function setAttribute(entity, tag, value, id) {
+    if (!(entity instanceof Insert)) {
+        throw new DwgCliError(`Entity is not a block insert: ${id}`, "ENTITY_NOT_INSERT", EXIT_USER_ERROR);
+    }
+    const attr = [...entity.attributes].find((item) => item.tag.toLowerCase() === tag.toLowerCase());
+    if (!attr) {
+        throw new DwgCliError(`Attribute not found on ${id}: ${tag}`, "ATTRIBUTE_NOT_FOUND", EXIT_USER_ERROR);
+    }
+    attr.value = value;
+}
+function applyOperation(doc, operation) {
+    switch (operation.kind) {
+        case "addPoint": {
+            const point = new Point(xyz(operation.at));
+            applyCommonOptions(doc, point, operation);
+            addEntity(doc, point);
+            return;
+        }
+        case "addLine": {
+            const line = new Line(xyz(operation.from), xyz(operation.to));
+            applyCommonOptions(doc, line, operation);
+            addEntity(doc, line);
+            return;
+        }
+        case "addCircle": {
+            const circle = new Circle();
+            circle.center = xyz(operation.center);
+            circle.radius = operation.radius;
+            applyCommonOptions(doc, circle, operation);
+            addEntity(doc, circle);
+            return;
+        }
+        case "addArc": {
+            const arc = new Arc(xyz(operation.center), operation.radius, degreesToRadians(operation.startAngleDegrees), degreesToRadians(operation.endAngleDegrees));
+            applyCommonOptions(doc, arc, operation);
+            addEntity(doc, arc);
+            return;
+        }
+        case "addText": {
+            const text = new TextEntity();
+            text.value = operation.text;
+            text.insertPoint = xyz(operation.at);
+            if (operation.height !== undefined)
+                text.height = operation.height;
+            if (operation.rotationDegrees !== undefined) {
+                text.rotation = degreesToRadians(operation.rotationDegrees);
+            }
+            applyCommonOptions(doc, text, operation);
+            addEntity(doc, text);
+            return;
+        }
+        case "addMText": {
+            const text = new MText();
+            text.value = operation.text;
+            text.insertPoint = xyz(operation.at);
+            if (operation.height !== undefined)
+                text.height = operation.height;
+            if (operation.width !== undefined)
+                text.rectangleWidth = operation.width;
+            if (operation.rotationDegrees !== undefined) {
+                text.rotation = degreesToRadians(operation.rotationDegrees);
+            }
+            applyCommonOptions(doc, text, operation);
+            addEntity(doc, text);
+            return;
+        }
+        case "addPolyline": {
+            const polyline = new LwPolyline(operation.points.map(xy));
+            polyline.isClosed = operation.closed ?? false;
+            applyCommonOptions(doc, polyline, operation);
+            addEntity(doc, polyline);
+            return;
+        }
+    }
+    const entity = findEntity(doc, operation.entityId);
+    switch (operation.kind) {
+        case "setText":
+            if (!(entity instanceof TextEntity || entity instanceof MText)) {
+                throw new DwgCliError(`Entity is not editable text: ${operation.entityId}`, "ENTITY_NOT_TEXT", EXIT_USER_ERROR);
+            }
+            entity.value = operation.text;
+            return;
+        case "setLayer":
+            entity.layer = ensureLayer(doc, operation.layer);
+            return;
+        case "setColor":
+            entity.color = acadColor(operation.color);
+            return;
+        case "setLineType":
+            entity.lineType = ensureLineType(doc, operation.lineType);
+            return;
+        case "setLineWeight":
+            entity.lineWeight = lineWeight(operation.weight);
+            return;
+        case "setTransparency":
+            entity.transparency = Transparency.fromAlphaValue(operation.alpha);
+            return;
+        case "setVisibility":
+            entity.isInvisible = !operation.visible;
+            return;
+        case "move":
+            entity.applyTranslation(new XYZ(operation.dx, operation.dy, operation.dz ?? 0));
+            return;
+        case "rotate": {
+            const origin = operation.origin ? xyz(operation.origin) : XYZ.zero;
+            entity.applyTranslation(new XYZ(-origin.x, -origin.y, -origin.z));
+            entity.applyRotation(XYZ.axisZ, degreesToRadians(operation.angleDegrees));
+            entity.applyTranslation(origin);
+            return;
+        }
+        case "scale":
+            entity.applyScaling(new XYZ(operation.factor, operation.factor, operation.factor), operation.origin ? xyz(operation.origin) : XYZ.zero);
+            return;
+        case "copy": {
+            const clone = entity.clone();
+            clone.applyTranslation(new XYZ(operation.dx ?? 0, operation.dy ?? 0, operation.dz ?? 0));
+            addEntity(doc, clone);
+            return;
+        }
+        case "matchProperties": {
+            const source = findEntity(doc, operation.sourceId);
+            entity.matchProperties(source);
+            return;
+        }
+        case "setAttribute":
+            setAttribute(entity, operation.tag, operation.value, operation.entityId);
+            return;
+        case "delete":
+            deleteEntity(entity, operation.entityId);
+            return;
+    }
+}
+export function editWithAcadTs(opts) {
+    if (opts.operations.length === 0) {
+        throw new DwgCliError("No acad-ts edit operation specified.", "MISSING_EDIT_OPERATION", EXIT_USER_ERROR);
+    }
+    if (opts.input === opts.output && !opts.overwrite) {
+        throw new DwgCliError("Refusing to edit in place without --overwrite. Provide --output or pass --overwrite.", "EDIT_REQUIRES_OUTPUT_OR_OVERWRITE", EXIT_USER_ERROR);
+    }
+    const { bytes, doc, format } = readAcadFile(opts.input);
+    for (const operation of opts.operations)
+        applyOperation(doc, operation);
+    writeOutput(opts.output, writeAcadDocument(doc, format, bytes.length));
+    return {
+        input: opts.input,
+        output: opts.output,
+        backend: "acad-ts",
+        operations: opts.operations,
+        changed: opts.operations.length,
+    };
+}

package/dist/core/acad-view.d.ts

@@ -0,0 +1,6 @@
+export interface AcadSvgViewResult {
+    input: string;
+    svg: string;
+    backend: "acad-ts";
+}
+export declare function renderSvgWithAcadTs(file: string): AcadSvgViewResult;

package/dist/core/acad-view.js

@@ -0,0 +1,22 @@
+import { Color } from "@node-projects/acad-ts";
+import { readAcadFile, writeAcadSvg } from "./acad.js";
+// acad-ts SvgWriter currently crashes when text resolves ByLayer/ByBlock
+// through an index that has no RGB entry. Normalize render-only colors here;
+// the source file is untouched because view reparses the document every time.
+function makeEntityColorsRenderable(doc) {
+    for (const entity of doc.modelSpace?.entities ?? []) {
+        const candidate = entity;
+        if (candidate.color?.isByLayer || candidate.color?.isByBlock) {
+            candidate.color = Color.black;
+        }
+    }
+}
+export function renderSvgWithAcadTs(file) {
+    const { doc } = readAcadFile(file);
+    makeEntityColorsRenderable(doc);
+    return {
+        input: file,
+        svg: writeAcadSvg(doc),
+        backend: "acad-ts",
+    };
+}

package/dist/core/acad.d.ts

@@ -0,0 +1,11 @@
+import { type CadDocument } from "@node-projects/acad-ts";
+import type { DwgFormat } from "../types.js";
+export interface AcadFile {
+    bytes: Uint8Array;
+    doc: CadDocument;
+    format: DwgFormat;
+}
+export declare function parseAcadDocument(bytes: Uint8Array, format: DwgFormat): CadDocument;
+export declare function readAcadFile(file: string): AcadFile;
+export declare function writeAcadDocument(doc: CadDocument, format: DwgFormat, originalBytes: number): Uint8Array;
+export declare function writeAcadSvg(doc: CadDocument): string;

package/dist/core/acad.js

@@ -0,0 +1,82 @@
+import { DwgReader, DwgWriter, DxfReader, DxfWriter, SvgWriter, } from "@node-projects/acad-ts";
+import { EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { arrayBufferFor } from "./adapter.js";
+import { DwgCliError } from "./errors.js";
+import { readCadFile } from "./files.js";
+export function parseAcadDocument(bytes, format) {
+    try {
+        return format === "DWG"
+            ? DwgReader.readFromStream(arrayBufferFor(bytes))
+            : DxfReader.readFromStream(bytes);
+    }
+    catch (error) {
+        throw new DwgCliError(`Could not parse ${format}: ${error.message}`, "PARSE_FAILED", EXIT_USER_ERROR);
+    }
+}
+export function readAcadFile(file) {
+    const { bytes, format } = readCadFile(file);
+    return { bytes, format, doc: parseAcadDocument(bytes, format) };
+}
+function writeDwg(doc, originalBytes) {
+    let size = Math.max(1024 * 1024, originalBytes * 4);
+    const maxSize = 512 * 1024 * 1024;
+    while (size <= maxSize) {
+        const buffer = new ArrayBuffer(size);
+        const writer = new DwgWriter(buffer, doc);
+        writer.write();
+        if (writer.bytesWritten <= size) {
+            return new Uint8Array(buffer).slice(0, writer.bytesWritten);
+        }
+        size *= 2;
+    }
+    throw new DwgCliError("Could not write DWG: output exceeded the maximum supported buffer size.", "ACAD_WRITE_FAILED", EXIT_USER_ERROR);
+}
+function writeDxf(doc) {
+    let content = "";
+    DxfWriter.writeToStream({
+        write(value) {
+            content +=
+                typeof value === "string" ? value : new TextDecoder().decode(value);
+        },
+        flush() { },
+        close() { },
+    }, doc);
+    return new TextEncoder().encode(content);
+}
+export function writeAcadDocument(doc, format, originalBytes) {
+    try {
+        return format === "DWG" ? writeDwg(doc, originalBytes) : writeDxf(doc);
+    }
+    catch (error) {
+        if (error instanceof DwgCliError)
+            throw error;
+        throw new DwgCliError(`Could not write ${format}: ${error.message}`, "ACAD_WRITE_FAILED", EXIT_USER_ERROR);
+    }
+}
+function trimNullPadding(bytes) {
+    const end = bytes.indexOf(0);
+    return end === -1 ? bytes : bytes.slice(0, end);
+}
+function isOutputCapacityError(error) {
+    return /offset is out of bounds|too small|outside the bounds/i.test(error.message);
+}
+export function writeAcadSvg(doc) {
+    let size = 1024 * 1024;
+    const maxSize = 256 * 1024 * 1024;
+    while (size <= maxSize) {
+        const output = new Uint8Array(size);
+        try {
+            const writer = new SvgWriter(output, doc);
+            writer.write();
+            writer.dispose();
+            return new TextDecoder().decode(trimNullPadding(output));
+        }
+        catch (error) {
+            if (!isOutputCapacityError(error) || size >= maxSize) {
+                throw new DwgCliError(`Could not render SVG with acad-ts: ${error.message}`, "ACAD_SVG_FAILED", EXIT_USER_ERROR);
+            }
+            size *= 2;
+        }
+    }
+    throw new DwgCliError("Could not render SVG with acad-ts: output exceeded the maximum supported buffer size.", "ACAD_SVG_FAILED", EXIT_USER_ERROR);
+}

package/dist/core/adapter.d.ts

@@ -6,9 +6,3 @@ export declare class AcadTsReader implements DrawingReader {
     parse(_file: string, bytes: Uint8Array, format: DwgFormat): Promise<unknown>;
     thumbnail(): Promise<ThumbnailResult | null>;
 }
-export declare class NativeLibreDwgReader implements DrawingReader {
-    private readonly toolDir?;
-    constructor(toolDir?: string | undefined);
-    parse(file: string, _bytes: Uint8Array, _format: DwgFormat): Promise<unknown>;
-    thumbnail(): Promise<ThumbnailResult | null>;
-}

package/dist/core/adapter.js

@@ -1,7 +1,6 @@
 import { DwgReader, DxfReader } from "@node-projects/acad-ts";
 import { EXIT_UNAVAILABLE, EXIT_USER_ERROR } from "../utils/exit-codes.js";
 import { DwgCliError } from "./errors.js";
-import { readJsonWithLibreDwg } from "./libredwg.js";
 function asRecord(value) {
     return value && typeof value === "object"
         ? value
@@ -151,15 +150,3 @@ export class AcadTsReader {
         throw new DwgCliError("Thumbnail extraction is not available through acad-ts.", "THUMBNAIL_UNAVAILABLE", EXIT_UNAVAILABLE);
     }
 }
-export class NativeLibreDwgReader {
-    toolDir;
-    constructor(toolDir) {
-        this.toolDir = toolDir;
-    }
-    async parse(file, _bytes, _format) {
-        return readJsonWithLibreDwg(file, { toolDir: this.toolDir }).json;
-    }
-    async thumbnail() {
-        throw new DwgCliError("Thumbnail extraction is not available through native LibreDWG.", "THUMBNAIL_UNAVAILABLE", EXIT_UNAVAILABLE);
-    }
-}

package/dist/core/drawing.d.ts

@@ -1,7 +1,6 @@
 import type { DrawingReader, DwgBlock, DwgDocument, DwgEntity, DwgLayer, EntityFilter, SvgResult, ThumbnailResult } from "../types.js";
 export interface LoadOptions {
     reader?: DrawingReader;
-    toolDir?: string;
 }
 export declare function loadDrawing(file: string, opts?: LoadOptions): Promise<DwgDocument>;
 export declare function getInfo(file: string, opts?: LoadOptions): Promise<import("../types.js").DwgSummary>;

package/dist/core/search.d.ts

@@ -15,4 +15,7 @@ export interface DwgSearchResult {
     matches: string[];
     entity: DwgEntity;
 }
+export declare function stringifySearchValue(value: unknown): string;
+export declare function entitySearchFields(entity: DwgEntity): string[];
+export declare function searchMatchesFor(entity: DwgEntity, query: string | undefined): string[];
 export declare function searchDrawing(file: string, opts?: DwgSearchOptions, loadOpts?: LoadOptions): Promise<DwgSearchResult[]>;

package/dist/core/search.js

@@ -1,48 +1,23 @@
-import MiniSearch from "minisearch";
 import { loadDrawing } from "./drawing.js";
 import { computeDrawingFingerprint, loadSearchCache, saveSearchCache, } from "./search-cache.js";
-const SEARCH_FIELDS = ["entityId", "type", "layer", "text"];
-const STORE_FIELDS = ["entityId", "type", "layer", "text"];
 const DEFAULT_LIMIT = 30;
 const MAX_MATCHES = 5;
-function createSearchIndex() {
-    return new MiniSearch({
-        fields: [...SEARCH_FIELDS],
-        storeFields: [...STORE_FIELDS],
-        searchOptions: {
-            boost: { entityId: 3, type: 2, layer: 2, text: 1 },
-            fuzzy: 0.2,
-            prefix: true,
-        },
-    });
-}
-function loadSearchIndex(indexJson) {
-    return MiniSearch.loadJSON(indexJson, {
-        fields: [...SEARCH_FIELDS],
-        storeFields: [...STORE_FIELDS],
-        searchOptions: {
-            boost: { entityId: 3, type: 2, layer: 2, text: 1 },
-            fuzzy: 0.2,
-            prefix: true,
-        },
-    });
-}
-function stringifyValue(value) {
+export function stringifySearchValue(value) {
     if (value === null || value === undefined)
         return "";
     if (["string", "number", "boolean", "bigint"].includes(typeof value)) {
         return String(value);
     }
     if (Array.isArray(value))
-        return value.map(stringifyValue).join(" ");
+        return value.map(stringifySearchValue).join(" ");
     if (typeof value === "object") {
         return Object.entries(value)
-            .map(([key, val]) => `${key} ${stringifyValue(val)}`)
+            .map(([key, val]) => `${key} ${stringifySearchValue(val)}`)
             .join(" ");
     }
     return "";
 }
-function textFields(entity) {
+export function entitySearchFields(entity) {
     const values = [
         entity.id,
         entity.type,
@@ -52,24 +27,28 @@ function textFields(entity) {
         String(entity.data.name ?? ""),
         String(entity.data.blockName ?? ""),
         String(entity.data.block_name ?? ""),
-        stringifyValue(entity.data),
+        stringifySearchValue(entity.data),
     ];
     return values.filter((value) => value.trim().length > 0);
 }
-function buildDocs(doc) {
+function buildScanDocs(doc) {
     return doc.entities.map((entity, id) => ({
         id,
         entityId: entity.id,
         type: entity.type,
         layer: entity.layer,
-        text: textFields(entity).join(" "),
+        text: entitySearchFields(entity).join(" "),
         entity,
     }));
 }
-function buildIndex(docs) {
-    const index = createSearchIndex();
-    index.addAll(docs);
-    return index;
+async function loadScanCorpus(file, opts, loadOpts) {
+    const fingerprint = computeDrawingFingerprint(file);
+    const cached = loadSearchCache(file, fingerprint, opts.cacheDir);
+    if (cached)
+        return cached.docs;
+    const docs = buildScanDocs(await loadDrawing(file, loadOpts));
+    saveSearchCache(file, { fingerprint, index: "scan", docs }, opts.cacheDir);
+    return docs;
 }
 function matchesFilter(doc, opts) {
     if (opts.type && doc.type.toLowerCase() !== opts.type.toLowerCase()) {
@@ -80,58 +59,69 @@ function matchesFilter(doc, opts) {
     }
     return true;
 }
-function matchesFor(doc, query) {
+export function searchMatchesFor(entity, query) {
     if (!query)
         return [];
     const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
     if (terms.length === 0)
         return [];
-    return textFields(doc.entity)
+    return entitySearchFields(entity)
         .filter((chunk) => {
         const lower = chunk.toLowerCase();
         return terms.some((term) => lower.includes(term));
     })
         .slice(0, MAX_MATCHES);
 }
-async function loadSearchCorpus(file, opts, loadOpts) {
-    const fingerprint = computeDrawingFingerprint(file);
-    const cached = loadSearchCache(file, fingerprint, opts.cacheDir);
-    if (cached) {
-        return {
-            docs: cached.docs,
-            index: loadSearchIndex(cached.index),
-        };
+function queryTerms(query) {
+    return query?.toLowerCase().split(/\s+/).filter(Boolean) ?? [];
+}
+function scanScore(doc, terms) {
+    if (terms.length === 0)
+        return 1;
+    const entityId = doc.entityId.toLowerCase();
+    const type = doc.type.toLowerCase();
+    const layer = doc.layer?.toLowerCase() ?? "";
+    const text = doc.text.toLowerCase();
+    let score = 0;
+    for (const term of terms) {
+        if (entityId.includes(term))
+            score += 3;
+        if (type.includes(term))
+            score += 2;
+        if (layer.includes(term))
+            score += 2;
+        if (text.includes(term))
+            score += 1;
     }
-    const docs = buildDocs(await loadDrawing(file, loadOpts));
-    const index = buildIndex(docs);
-    saveSearchCache(file, { fingerprint, index: JSON.stringify(index), docs }, opts.cacheDir);
-    return { docs, index };
+    return score;
 }
-function resultScore(result) {
-    return Math.round((Number(result.score) || 1) * 10) / 10;
+function resultScore(score) {
+    return Math.round((score || 1) * 10) / 10;
 }
-export async function searchDrawing(file, opts = {}, loadOpts = {}) {
-    const { docs, index } = await loadSearchCorpus(file, opts, loadOpts);
+async function searchWithScan(file, opts = {}, loadOpts = {}) {
+    const docs = await loadScanCorpus(file, opts, loadOpts);
     const query = opts.query?.trim();
-    const byId = new Map(docs.map((doc) => [doc.id, doc]));
-    const raw = query
-        ? index.search(query).map((result) => ({
-            id: Number(result.id),
-            score: result.score,
-        }))
-        : docs.map((doc) => ({ id: doc.id, score: 1 }));
-    return raw
-        .map((result) => ({ result, doc: byId.get(result.id) }))
-        .filter((item) => Boolean(item.doc))
-        .filter(({ doc }) => matchesFilter(doc, opts))
-        .map(({ result, doc }) => ({
+    const terms = queryTerms(query);
+    return docs
+        .filter((doc) => matchesFilter(doc, opts))
+        .map((doc) => ({ doc, score: scanScore(doc, terms) }))
+        .filter(({ score }) => terms.length === 0 || score > 0)
+        .map(({ doc, score }) => ({
         entityId: doc.entityId,
         type: doc.type,
         layer: doc.layer,
-        score: resultScore(result),
-        matches: opts.snippets === false ? [] : matchesFor(doc, query),
+        score: resultScore(score),
+        matches: opts.snippets === false ? [] : searchMatchesFor(doc.entity, query),
         entity: doc.entity,
     }))
         .sort((a, b) => b.score - a.score)
         .slice(0, opts.limit ?? DEFAULT_LIMIT);
 }
+async function searchWithDiskIndex(file, opts, loadOpts) {
+    const { searchWithSqlite } = await import("./sqlite-search.js");
+    return searchWithSqlite(file, opts, loadOpts);
+}
+export async function searchDrawing(file, opts = {}, loadOpts = {}) {
+    return ((await searchWithDiskIndex(file, opts, loadOpts)) ??
+        searchWithScan(file, opts, loadOpts));
+}

package/dist/core/sqlite-search.d.ts

@@ -0,0 +1,3 @@
+import { type LoadOptions } from "./drawing.js";
+import { type DwgSearchOptions, type DwgSearchResult } from "./search.js";
+export declare function searchWithSqlite(file: string, opts: DwgSearchOptions, loadOpts: LoadOptions): Promise<DwgSearchResult[] | null>;