@miclivs/cadcli 0.1.2 → 0.3.0

package/dist/core/query.js

@@ -0,0 +1,232 @@
+import { EXIT_UNAVAILABLE, EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { DwgCliError } from "./errors.js";
+const QUERY_SCHEMA_TABLES = [
+    {
+        name: "summary",
+        description: "One-row drawing summary.",
+        columns: [
+            { name: "file", type: "text" },
+            { name: "format", type: "text" },
+            { name: "version", type: "text" },
+            { name: "entity_count", type: "integer" },
+            { name: "layer_count", type: "integer" },
+            { name: "block_count", type: "integer" },
+            { name: "unsupported_count", type: "integer" },
+        ],
+    },
+    {
+        name: "metadata",
+        description: "Document metadata and normalization notes.",
+        columns: [
+            { name: "key", type: "text" },
+            { name: "value", type: "text" },
+        ],
+    },
+    {
+        name: "layers",
+        description: "Drawing layers and entity counts.",
+        columns: [
+            { name: "name", type: "text" },
+            { name: "entity_count", type: "integer" },
+        ],
+    },
+    {
+        name: "blocks",
+        description: "Block definitions and definition entity counts.",
+        columns: [
+            { name: "name", type: "text" },
+            { name: "entity_count", type: "integer" },
+        ],
+    },
+    {
+        name: "entities",
+        description: "All normalized model-space entities, projected narrowly.",
+        columns: [
+            { name: "id", type: "text" },
+            { name: "type", type: "text" },
+            { name: "layer", type: "text" },
+            { name: "color", type: "text" },
+        ],
+    },
+    {
+        name: "texts",
+        description: "TEXT and MTEXT entities with normalized text and insertion points.",
+        columns: [
+            { name: "id", type: "text" },
+            { name: "type", type: "text" },
+            { name: "layer", type: "text" },
+            { name: "text", type: "text" },
+            { name: "x", type: "real" },
+            { name: "y", type: "real" },
+            { name: "text_style", type: "text" },
+            { name: "text_style_file", type: "text" },
+        ],
+    },
+    {
+        name: "inserts",
+        description: "Placed block instances with insertion points.",
+        columns: [
+            { name: "id", type: "text" },
+            { name: "layer", type: "text" },
+            { name: "block_name", type: "text" },
+            { name: "x", type: "real" },
+            { name: "y", type: "real" },
+        ],
+    },
+];
+export function querySchema() {
+    return QUERY_SCHEMA_TABLES.map((table) => `${table.name}(${table.columns.map((column) => column.name).join(", ")})`).join("\n");
+}
+export function querySchemaTables() {
+    return QUERY_SCHEMA_TABLES;
+}
+async function openMemoryDatabase() {
+    try {
+        const { default: Database } = await import("better-sqlite3");
+        return new Database(":memory:");
+    }
+    catch {
+        throw new DwgCliError("cadcli query requires the optional better-sqlite3 dependency.", "QUERY_UNAVAILABLE", EXIT_UNAVAILABLE);
+    }
+}
+function sqlValue(value) {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value === "number" || typeof value === "string")
+        return value;
+    return String(value);
+}
+function point(entity) {
+    const value = entity.data.insertionPoint ?? entity.data.position ?? entity.data.point;
+    if (!value || typeof value !== "object")
+        return { x: null, y: null };
+    const rec = value;
+    const x = Number(rec.x ?? rec.X);
+    const y = Number(rec.y ?? rec.Y);
+    return {
+        x: Number.isFinite(x) ? x : null,
+        y: Number.isFinite(y) ? y : null,
+    };
+}
+function textValue(entity) {
+    const value = entity.data.text ?? entity.data.value ?? entity.data.Text;
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function blockName(entity) {
+    const value = entity.data.blockName ?? entity.data.block_name ?? entity.data.name;
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function createSchema(db) {
+    db.exec(`
+    CREATE TABLE summary (
+      file TEXT,
+      format TEXT,
+      version TEXT,
+      entity_count INTEGER,
+      layer_count INTEGER,
+      block_count INTEGER,
+      unsupported_count INTEGER
+    );
+    CREATE TABLE metadata (key TEXT PRIMARY KEY, value TEXT);
+    CREATE TABLE layers (name TEXT PRIMARY KEY, entity_count INTEGER);
+    CREATE TABLE blocks (name TEXT PRIMARY KEY, entity_count INTEGER);
+    CREATE TABLE entities (id TEXT PRIMARY KEY, type TEXT, layer TEXT, color TEXT);
+    CREATE TABLE texts (
+      id TEXT PRIMARY KEY,
+      type TEXT,
+      layer TEXT,
+      text TEXT,
+      x REAL,
+      y REAL,
+      text_style TEXT,
+      text_style_file TEXT
+    );
+    CREATE TABLE inserts (
+      id TEXT PRIMARY KEY,
+      layer TEXT,
+      block_name TEXT,
+      x REAL,
+      y REAL
+    );
+  `);
+}
+function registerFunctions(db) {
+    db.function("regexp", (pattern, value) => {
+        if (typeof pattern !== "string" || value === null || value === undefined) {
+            return 0;
+        }
+        try {
+            return new RegExp(pattern, "u").test(String(value)) ? 1 : 0;
+        }
+        catch {
+            return 0;
+        }
+    });
+}
+function insertDocument(db, doc) {
+    db.prepare("INSERT INTO summary VALUES (?, ?, ?, ?, ?, ?, ?)").run(doc.summary.file, doc.summary.format, doc.summary.version ?? null, doc.summary.counts.entities, doc.summary.counts.layers, doc.summary.counts.blocks, doc.summary.counts.unsupported);
+    const insertMetadata = db.prepare("INSERT INTO metadata VALUES (?, ?)");
+    if (doc.metadata.codePage)
+        insertMetadata.run("code_page", doc.metadata.codePage);
+    if (doc.metadata.textNormalization) {
+        insertMetadata.run("text_normalization_applied", doc.metadata.textNormalization.applied.join(","));
+        insertMetadata.run("text_normalization_entities_changed", doc.metadata.textNormalization.entitiesChanged);
+    }
+    const insertLayer = db.prepare("INSERT INTO layers VALUES (?, ?)");
+    const insertBlock = db.prepare("INSERT INTO blocks VALUES (?, ?)");
+    const insertEntity = db.prepare("INSERT INTO entities VALUES (?, ?, ?, ?)");
+    const insertText = db.prepare("INSERT INTO texts VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
+    const insertInsert = db.prepare("INSERT INTO inserts VALUES (?, ?, ?, ?, ?)");
+    db.exec("BEGIN");
+    try {
+        for (const layer of doc.layers)
+            insertLayer.run(layer.name, layer.entityCount);
+        for (const block of doc.blocks)
+            insertBlock.run(block.name, block.entityCount);
+        for (const entity of doc.entities) {
+            insertEntity.run(entity.id, entity.type, entity.layer ?? null, sqlValue(entity.color));
+            const { x, y } = point(entity);
+            const text = textValue(entity);
+            if ((entity.type === "TEXT" || entity.type === "MTEXT") && text) {
+                insertText.run(entity.id, entity.type, entity.layer ?? null, text, x, y, sqlValue(entity.data.textStyle), sqlValue(entity.data.textStyleFile));
+            }
+            if (entity.type === "INSERT") {
+                insertInsert.run(entity.id, entity.layer ?? null, blockName(entity), x, y);
+            }
+        }
+        db.exec("COMMIT");
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+}
+function ensureSelectQuery(sql) {
+    const trimmed = sql.trim();
+    if (!/^(select|with)\b/i.test(trimmed)) {
+        throw new DwgCliError("Query SQL must be a SELECT statement.", "INVALID_QUERY_SQL", EXIT_USER_ERROR);
+    }
+}
+function ensureReadOnlyStatement(statement) {
+    if (statement.readonly === false) {
+        throw new DwgCliError("Query SQL must be read-only.", "INVALID_QUERY_SQL", EXIT_USER_ERROR);
+    }
+}
+export async function queryDrawing(doc, sql) {
+    ensureSelectQuery(sql);
+    const db = await openMemoryDatabase();
+    try {
+        createSchema(db);
+        registerFunctions(db);
+        insertDocument(db, doc);
+        const statement = db.prepare(sql);
+        ensureReadOnlyStatement(statement);
+        const rows = statement.all();
+        const columns = statement.columns?.().map((column) => column.name) ??
+            Object.keys(rows[0] ?? {});
+        return { columns, rows };
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/core/text-normalize.d.ts

@@ -0,0 +1,3 @@
+import type { DwgDocument } from "../types.js";
+export declare function normalizeHebrewKeyboardText(text: string): string;
+export declare function normalizeTextAuto(doc: DwgDocument): DwgDocument;

package/dist/core/text-normalize.js

@@ -0,0 +1,104 @@
+import hebrewLayout from "convert-layout/he.js";
+const TEXT_NORMALIZATION_ROUTES = [
+    {
+        name: "hebrew-keyboard",
+        codePages: ["ansi_1255"],
+        textStyleFiles: ["gil.shx", "narkism$.shx", "heb.shx", "oron", "oron1"],
+        fromLatinKeyboard: hebrewLayout.fromEn,
+        targetScript: "hebrew",
+    },
+];
+function asText(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function normalizedToken(value) {
+    return value?.trim().toLowerCase();
+}
+function textStyleFile(entity) {
+    return normalizedToken(asText(entity.data.textStyleFile));
+}
+function isTextEntity(entity) {
+    return entity.type === "TEXT" || entity.type === "MTEXT";
+}
+function hasTargetScript(text, script) {
+    switch (script) {
+        case "hebrew":
+            return /[\u0590-\u05ff]/u.test(text);
+    }
+}
+function targetScriptCount(text, script) {
+    switch (script) {
+        case "hebrew":
+            return text.match(/[\u0590-\u05ff]/gu)?.length ?? 0;
+    }
+}
+function mostlyLatinKeyboardText(text, targetScript) {
+    const latinLetters = text.match(/[A-Za-z]/g)?.length ?? 0;
+    return latinLetters > 0 && targetScriptCount(text, targetScript) === 0;
+}
+function routeMatches(route, doc, entity) {
+    const codePage = normalizedToken(doc.metadata.codePage);
+    const styleFile = textStyleFile(entity);
+    return Boolean(codePage &&
+        styleFile &&
+        route.codePages.includes(codePage) &&
+        route.textStyleFiles.includes(styleFile));
+}
+function routeFor(doc, entity) {
+    return TEXT_NORMALIZATION_ROUTES.find((route) => routeMatches(route, doc, entity));
+}
+function normalizeEntityText(doc, entity) {
+    if (!isTextEntity(entity))
+        return { entity };
+    const route = routeFor(doc, entity);
+    if (!route)
+        return { entity };
+    const text = asText(entity.data.text);
+    if (!text || !mostlyLatinKeyboardText(text, route.targetScript)) {
+        return { entity };
+    }
+    const normalized = route.fromLatinKeyboard(text);
+    if (normalized === text || !hasTargetScript(normalized, route.targetScript)) {
+        return { entity };
+    }
+    return {
+        normalizer: route.name,
+        entity: {
+            ...entity,
+            data: {
+                ...entity.data,
+                text: normalized,
+            },
+        },
+    };
+}
+export function normalizeHebrewKeyboardText(text) {
+    return hebrewLayout.fromEn(text);
+}
+export function normalizeTextAuto(doc) {
+    const applied = new Set();
+    let entitiesChanged = 0;
+    const entities = doc.entities.map((entity) => {
+        const result = normalizeEntityText(doc, entity);
+        if (!result.normalizer)
+            return entity;
+        entitiesChanged++;
+        applied.add(result.normalizer);
+        return result.entity;
+    });
+    if (entitiesChanged === 0)
+        return doc;
+    const unsupportedIds = new Set(doc.unsupported.map((entity) => entity.id));
+    return {
+        ...doc,
+        entities,
+        unsupported: entities.filter((entity) => unsupportedIds.has(entity.id)),
+        metadata: {
+            ...doc.metadata,
+            textNormalization: {
+                applied: [...applied],
+                entitiesChanged,
+            },
+        },
+    };
+}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export type { LibreDwgEditResult, LibreDwgJsonResult, LibreDwgViewResult, } from "./core/libredwg.js";
+export type { AcadColor, AcadEditOperation, AcadEditResult, AcadPoint, } from "./core/acad-edit.js";
+export type { AcadSvgViewResult } from "./core/acad-view.js";
 export type { DrawingOverview, DrawingOverviewOptions, OverviewBlock, OverviewEntityType, OverviewLayer, OverviewText, } from "./core/overview.js";
 export type { DwgSearchOptions, DwgSearchResult } from "./core/search.js";
 export { Dwg } from "./sdk.js";

package/dist/main.js

@@ -9,6 +9,7 @@ import { info } from "./commands/info.js";
 import { json } from "./commands/json.js";
 import { layers } from "./commands/layers.js";
 import { overview } from "./commands/overview.js";
+import { query } from "./commands/query.js";
 import { search } from "./commands/search.js";
 import { svg } from "./commands/svg.js";
 import { thumbnail } from "./commands/thumbnail.js";
@@ -27,8 +28,10 @@ Examples:
   $ cadcli layers drawing.dwg --json     List layers for scripts/agents
   $ cadcli entities drawing.dwg --type LINE --limit 20
   $ cadcli search drawing.dwg "conference" --layer A-TEXT
+  $ cadcli query drawing.dwg --sql "select text, x, y from texts"
   $ cadcli view drawing.dwg -o drawing.svg
-  $ cadcli edit drawing.dwg --jq '.OBJECTS[]' -o edited.dwg
+  $ cadcli edit drawing.dwg --set-text "Office" --text-id 2A -o edited.dwg
+  $ cadcli edit drawing.dwg --add-line 0,0:10,0 --new-layer A-WALL -o edited.dwg
 
 Workflow: info → overview → search/entities → view/edit
 
@@ -39,16 +42,23 @@ Inspecting:
   blocks <file>        List blocks
   entities <file>      List/filter entities
   search <file>        Search entities by text, type, layer, and raw fields
+  query <file>         Query normalized CAD tables with SQL
 
 Viewing and editing:
-  view <file>          Render a high-fidelity SVG preview
-  edit <file>          Edit DWG/DXF with jq-style expressions
+  view <file>          Render an SVG preview
+  edit <file>          Edit DWG/DXF with acad-ts operations
 
 Conversion:
   json <file>          Export normalized JSON
   svg <file>           Render best-effort SVG from normalized JSON
   thumbnail <file>     Extract embedded thumbnail when available
 
+Querying:
+  query <file>         Query normalized CAD tables with SQL
+    --schema           Show available query tables
+    --sql <query>      Run an inline SELECT query
+    --file <path>      Read a SELECT query from a file
+
 Options:
   --json               Output as JSON
   -q, --quiet          Suppress non-essential output
@@ -118,17 +128,98 @@ program
     root.query = root.query || queryWords.join(" ");
     await search(file, root);
 });
+program
+    .command("query <file>")
+    .description("Query normalized CAD tables with SQL")
+    .option("--sql <query>", "SQL SELECT query to run")
+    .option("--file <path>", "Read SQL query from a file")
+    .option("--schema", "Show available query tables")
+    .action(async (file, opts, cmd) => query(file, { ...cmd.optsWithGlobals(), ...opts }));
 program
     .command("view <file>")
-    .description("Render a high-fidelity SVG preview")
+    .description("Render an SVG preview")
     .option("-o, --output <path>", "Output SVG file")
     .action(async (file, opts, cmd) => view(file, { ...cmd.optsWithGlobals(), ...opts }));
 program
     .command("edit <file>")
-    .description("Edit DWG/DXF with jq-style expressions")
-    .requiredOption("--jq <expression>", "dwgfilter jq expression")
-    .option("-o, --output <path>", "Output file; defaults to input with --overwrite")
+    .description("Edit DWG/DXF with acad-ts operations")
+    .option("--set-text <text>", "Set TEXT/MTEXT content")
+    .option("--text-id <id>", "Entity id/handle for --set-text")
+    .option("--set-layer <name>", "Move an entity to a layer")
+    .option("--layer-id <id>", "Entity id/handle for --set-layer")
+    .option("--set-color <color>", "Set entity color: bylayer, byblock, index, #rrggbb, or r,g,b")
+    .option("--color-id <id>", "Entity id/handle for --set-color")
+    .option("--set-linetype <name>", "Set entity line type")
+    .option("--linetype-id <id>", "Entity id/handle for --set-linetype")
+    .option("--set-lineweight <n>", "Set entity line weight enum value")
+    .option("--lineweight-id <id>", "Entity id/handle for --set-lineweight")
+    .option("--set-transparency <alpha>", "Set transparency alpha value")
+    .option("--transparency-id <id>", "Entity id/handle for --set-transparency")
+    .option("--hide <id>", "Hide an entity")
+    .option("--show <id>", "Show an entity")
+    .option("--move <id>", "Move an entity by --dx/--dy/--dz")
+    .option("--rotate <id>", "Rotate an entity around Z by --angle degrees")
+    .option("--scale <id>", "Scale an entity by --factor")
+    .option("--copy <id>", "Copy an entity, optionally offset by --dx/--dy/--dz")
+    .option("--match-properties <id>", "Copy visual properties from --source-id")
+    .option("--source-id <id>", "Source entity id for --match-properties")
+    .option("--set-attr <tag=value>", "Set a block insert attribute")
+    .option("--insert-id <id>", "Block insert id for --set-attr")
+    .option("--dx <n>", "X delta")
+    .option("--dy <n>", "Y delta")
+    .option("--dz <n>", "Z delta")
+    .option("--angle <degrees>", "Angle in degrees")
+    .option("--origin <x,y,z>", "Origin for rotate/scale")
+    .option("--factor <n>", "Scale factor")
+    .option("--add-point <x,y,z>", "Add a POINT")
+    .option("--add-line <from:to>", "Add a LINE, e.g. 0,0:10,0")
+    .option("--add-circle <center:radius>", "Add a CIRCLE, e.g. 5,5:2")
+    .option("--add-arc <center:radius:start:end>", "Add an ARC with degree angles")
+    .option("--add-text <text>", "Add TEXT at --at")
+    .option("--add-mtext <text>", "Add MTEXT at --at")
+    .option("--points <p1;p2[;p3]>", "Add an LWPOLYLINE from x,y points")
+    .option("--closed", "Close a polyline added with --points")
+    .option("--at <x,y,z>", "Insertion point for text")
+    .option("--height <n>", "Text height")
+    .option("--width <n>", "MText width")
+    .option("--new-layer <name>", "Layer for add-* entities")
+    .option("--new-color <color>", "Color for add-* entities")
+    .option("--delete <id>", "Delete an entity")
+    .option("-o, --output <path>", "Write edited copy to this file; required unless --overwrite")
     .option("--overwrite", "Allow editing the input file in place")
+    .addHelpText("after", `
+
+Examples:
+  Find ids first:
+    $ cadcli entities drawing.dwg --type TEXT --json
+    $ cadcli search drawing.dwg "office" --json
+
+  Update existing entities:
+    $ cadcli edit drawing.dwg --set-text "Office" --text-id 2A -o edited.dwg
+    $ cadcli edit drawing.dwg --set-color '#ff0000' --color-id 2A -o edited.dwg
+    $ cadcli edit drawing.dwg --move 2A --dx 10 --dy 0 -o edited.dwg
+    $ cadcli edit drawing.dwg --rotate 2A --angle 90 --origin 0,0 -o edited.dwg
+    $ cadcli edit drawing.dwg --copy 2A --dx 10 --dy 0 -o edited.dwg
+    $ cadcli edit drawing.dwg --delete 2A -o edited.dwg
+
+  Add new entities:
+    $ cadcli edit drawing.dwg --add-line 0,0:10,0 --new-layer A-WALL -o edited.dwg
+    $ cadcli edit drawing.dwg --add-circle 5,5:2 -o edited.dwg
+    $ cadcli edit drawing.dwg --add-text "Label" --at 5,5 --height 2.5 -o edited.dwg
+    $ cadcli edit drawing.dwg --points '0,0;10,0;10,5' --closed -o edited.dwg
+
+Formats:
+  points:       x,y or x,y,z
+  line:         from:to, e.g. 0,0:10,0
+  circle:       center:radius, e.g. 5,5:2
+  arc:          center:radius:startAngle:endAngle, e.g. 5,5:2:0:90
+  color:        bylayer, byblock, AutoCAD color index, #rrggbb, or r,g,b
+
+Safety:
+  cadcli refuses to modify the input file by default.
+  Use -o/--output to write an edited copy.
+  Use --overwrite only when you intentionally want to edit the input file in place.
+`)
     .action(async (file, opts, cmd) => edit(file, { ...cmd.optsWithGlobals(), ...opts }));
 program
     .command("json <file>")

package/dist/sdk.d.ts

@@ -1,5 +1,6 @@
+import { type AcadEditOperation, type AcadEditResult } from "./core/acad-edit.js";
+import { type AcadSvgViewResult } from "./core/acad-view.js";
 import { type LoadOptions } from "./core/drawing.js";
-import { type LibreDwgEditResult, type LibreDwgViewResult } from "./core/libredwg.js";
 import { type DrawingOverview, type DrawingOverviewOptions } from "./core/overview.js";
 import { type DwgSearchOptions, type DwgSearchResult } from "./core/search.js";
 import type { DwgBlock, DwgDocument, DwgEntity, DwgLayer, DwgSummary, EntityFilter, SvgResult, ThumbnailResult } from "./types.js";
@@ -16,15 +17,12 @@ export declare class Dwg {
     overview(opts?: DrawingOverviewOptions): Promise<DrawingOverview>;
     json(): Promise<DwgDocument>;
     svg(): Promise<SvgResult>;
-    view(opts?: {
-        toolDir?: string;
-    }): LibreDwgViewResult;
+    view(): AcadSvgViewResult;
     edit(opts: {
         output: string;
-        expression: string;
+        operations: AcadEditOperation[];
         overwrite?: boolean;
-        toolDir?: string;
-    }): LibreDwgEditResult;
+    }): AcadEditResult;
     thumbnail(): Promise<ThumbnailResult>;
     static open(file: string, opts?: LoadOptions): Dwg;
 }

package/dist/sdk.js

@@ -1,5 +1,6 @@
+import { editWithAcadTs, } from "./core/acad-edit.js";
+import { renderSvgWithAcadTs, } from "./core/acad-view.js";
 import { getBlocks, getEntities, getInfo, getLayers, getThumbnail, loadDrawing, toJson, toSvg, } from "./core/drawing.js";
-import { editWithLibreDwgFilter, renderSvgWithLibreDwg, } from "./core/libredwg.js";
 import { getOverview, } from "./core/overview.js";
 import { searchDrawing, } from "./core/search.js";
 export class Dwg {
@@ -36,16 +37,15 @@ export class Dwg {
     svg() {
         return toSvg(this.file, this.opts);
     }
-    view(opts = {}) {
-        return renderSvgWithLibreDwg(this.file, opts);
+    view() {
+        return renderSvgWithAcadTs(this.file);
     }
     edit(opts) {
-        return editWithLibreDwgFilter({
+        return editWithAcadTs({
             input: this.file,
             output: opts.output,
-            expression: opts.expression,
+            operations: opts.operations,
             overwrite: opts.overwrite,
-            toolDir: opts.toolDir,
         });
     }
     thumbnail() {

package/dist/types.d.ts

@@ -35,8 +35,17 @@ export interface DwgSummary {
     };
     bounds?: DwgBounds;
 }
+export interface DwgTextNormalizationMetadata {
+    applied: string[];
+    entitiesChanged: number;
+}
+export interface DwgMetadata {
+    codePage?: string;
+    textNormalization?: DwgTextNormalizationMetadata;
+}
 export interface DwgDocument {
     summary: DwgSummary;
+    metadata: DwgMetadata;
     layers: DwgLayer[];
     blocks: DwgBlock[];
     entities: DwgEntity[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miclivs/cadcli",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Agent-friendly CAD inspection, search, viewing, and editing for DWG/DXF files.",
   "type": "module",
   "main": "dist/index.js",
@@ -49,7 +49,6 @@
     "cad",
     "cli",
     "sdk",
-    "libredwg",
     "svg",
     "conversion",
     "pi-package"
@@ -69,6 +68,7 @@
     "@node-projects/acad-ts": "2.3.0",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
+    "convert-layout": "^0.11.1",
     "nanoid": "^5.1.6"
   },
   "optionalDependencies": {