@gene-code/core 0.0.1

package/README.md

@@ -0,0 +1,41 @@
+# DSL
+
+```
+geneDiagram
+  gene <NAME>
+  length <N>              # total track length in coordinate units; optional (else inferred from max position)
+  exon <start> <end> [label]
+  variant <label> <pos> <class>
+```
+
+Variant classes → colors** (standard palette):
+
+class | color | meaning |
+|---|---|---|
+| missense | green | amino-acid substitution |
+| nonsense | red | premature stop |
+| frameshift | purple | indel shifting reading frame |
+| splice | orange | splice-site |
+| synonymous | gray | silent
+
+
+- Coordinate units - protein/aa
+
+
+## Real worls examples
+
+```
+geneDiagram
+  gene TP53
+  length 393
+  exon 94 312 DNA-binding
+  variant R175H 175 missense
+  variant R248Q 248 missense
+  variant R273H 273 missense
+  variant R213* 213 nonsense
+```
+## SVG layout
+
+- width 800, height ~200, padding 40
+- pos → padding + (pos/length) * (800 - 2*padding)
+-

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { splitRows } from "./src/dsl";
+import type { SVGString } from "./src/types";
+export { splitRows };
+/**
+ * Parses a DSL string into its diagram AST by dispatching on the first row's
+ * diagram keyword. Throws if the keyword is missing or unknown.
+ */
+export declare function parse(dsl: string): unknown;
+/**
+ * Renders a DSL string to an SVG. Returns null for empty, unknown, or
+ * malformed input (e.g. a partially-typed diagram) so callers can keep the
+ * previous output rather than handling thrown errors.
+ */
+export declare function render(dsl: string): SVGString | null;

package/dist/index.js

@@ -0,0 +1,542 @@
+// src/dsl.ts
+function splitRows(text) {
+  return text.split(`
+`).map((row) => row.trim()).filter((row) => row.length > 0);
+}
+function tokenize(text) {
+  return text.split(/\s+/);
+}
+
+// src/render.ts
+var WIDTH_PX = 800;
+var MARGIN_X = 10;
+var MARGIN_Y = 14;
+var INNER_WIDTH = WIDTH_PX - MARGIN_X * 2;
+function renderNode(node) {
+  switch (node.type) {
+    case "line":
+      return `<line x1="${node.x1}" x2="${node.x2}" y1="${node.y1}" y2="${node.y2}" stroke="black" />`;
+    case "rect":
+      return `<rect x="${node.x}" y="${node.y}" width="${node.width}" height="${node.height}" fill="${node.fill ?? "lightgray"}" stroke="${node.stroke ?? "black"}" />`;
+    case "text":
+      return `<text x="${node.x}" y="${node.y}" text-anchor="${node.anchor}" alignment-baseline="${node.baseline}" font-size="10">${node.text}</text>`;
+    case "circle":
+      return `<circle cx="${node.x}" cy="${node.y}" r="${node.radius}" fill="${node.color}" stroke="${node.stroke ?? "none"}" />`;
+    case "path":
+      return `<path d="${node.d}" fill="${node.fill ?? "none"}" stroke="${node.stroke ?? "none"}" />`;
+    case "group":
+      return `<g transform="translate(${node.x},${node.y})">
+        ${node.children.map(renderNode).join("")}
+      </g>`;
+    default:
+      return "";
+  }
+}
+function render(layout) {
+  const svg = `<svg viewBox="0 0 ${layout.width} ${layout.height}" width="100%" style="max-width:${layout.width}px"  xmlns="http://www.w3.org/2000/svg">
+    ${layout.nodes.map(renderNode).join("")}
+    </svg>`;
+  return svg;
+}
+
+// src/modules/geneDiagram.ts
+var Y_OFFSET_PX = 12;
+var FIRST_VARIANT_GAP_PX = 15;
+var BLOCK_HEIGHT_PX = 10;
+var LOLLIPOP_RADIUS_PX = 3;
+var ELBOW_RADIUS_PX = 3;
+var FONT_SIZE_PX = 10;
+var DOMAIN_LABEL_GAP_PX = BLOCK_HEIGHT_PX / 2 + MARGIN_Y - 4;
+function stemPath(x, y0, headX, y1) {
+  const dx = headX - x;
+  if (Math.abs(dx) < 0.5) {
+    return `M ${x} ${y0} L ${x} ${y1}`;
+  }
+  const dir = Math.sign(dx);
+  const jogY = (y0 + y1) / 2;
+  const r = Math.min(ELBOW_RADIUS_PX, Math.abs(dx) / 2, Math.abs(y0 - y1) / 4);
+  return [
+    `M ${x} ${y0}`,
+    `L ${x} ${jogY + r}`,
+    `Q ${x} ${jogY} ${x + dir * r} ${jogY}`,
+    `L ${headX - dir * r} ${jogY}`,
+    `Q ${headX} ${jogY} ${headX} ${jogY - r}`,
+    `L ${headX} ${y1}`
+  ].join(" ");
+}
+var VARIANT_COLORS = {
+  missense: "#d1495b",
+  nonsense: "#5b7c99",
+  frameshift: "#e0955b",
+  splice: "#5a9367",
+  synonymous: "#9a9a9a"
+};
+var DOMAIN_FILL = "#e4e0d8";
+var DOMAIN_STROKE = "#8c8577";
+var STEM_COLOR = "#5c5c5c";
+var HEAD_RING = "#fbfbfb";
+function parseDomain(words) {
+  const [start, end, ...rest] = words;
+  return {
+    start: Number(start),
+    end: Number(end),
+    ...rest.length ? { label: rest.join(" ") } : {}
+  };
+}
+function parseVariant(words) {
+  const [label, pos, varClass] = words;
+  if (!label || !pos || !varClass) {
+    throw new Error(`Invalid variant row: ${words.join(" ")}`);
+  }
+  if (Number.isNaN(Number(pos))) {
+    throw new Error(`Invalid variant position: ${pos}`);
+  }
+  return {
+    label,
+    pos: Number(pos),
+    class: varClass
+  };
+}
+var CHAR_WIDTH_PX = 6;
+var LABEL_GAP_PX = LOLLIPOP_RADIUS_PX + 2;
+var HEAD_DODGE_PX = 2 * LOLLIPOP_RADIUS_PX + 1;
+function labelWidth(v) {
+  return LABEL_GAP_PX + v.label.length * CHAR_WIDTH_PX;
+}
+function packVariants(variants, xScale) {
+  const sorted = [...variants].sort((a, b) => a.pos - b.pos);
+  const placed = [];
+  let prevPos = Number.NaN;
+  let prevHeadX = Number.NEGATIVE_INFINITY;
+  for (const variant of sorted) {
+    const x = xScale(variant.pos);
+    const headX = variant.pos === prevPos ? prevHeadX : Math.max(x, prevHeadX + HEAD_DODGE_PX);
+    prevPos = variant.pos;
+    prevHeadX = headX;
+    placed.push({ variant, x, headX, level: 0 });
+  }
+  for (let i = placed.length - 1;i >= 0; i--) {
+    const p = placed[i];
+    const labelEnd = p.headX + labelWidth(p.variant);
+    let level = 0;
+    for (let j = i + 1;j < placed.length; j++) {
+      const q = placed[j];
+      const samePos = q.variant.pos === p.variant.pos;
+      if (samePos || q.headX <= labelEnd) {
+        level = Math.max(level, q.level + 1);
+      }
+    }
+    p.level = level;
+  }
+  return placed;
+}
+function parse(rows) {
+  const diagram = { type: "geneDiagram", domains: [], variants: [] };
+  if (rows.length === 0) {
+    throw new Error("Empty DSL input");
+  }
+  for (const row of rows) {
+    const [keyword, ...rest] = tokenize(row);
+    switch (keyword) {
+      case "geneDiagram": {
+        diagram.type = "geneDiagram";
+        break;
+      }
+      case "length": {
+        diagram.length = Number(rest[0]);
+        break;
+      }
+      case "gene": {
+        diagram.gene = rest.join(" ");
+        break;
+      }
+      case "domain": {
+        diagram.domains.push(parseDomain(rest));
+        break;
+      }
+      case "variant": {
+        diagram.variants.push(parseVariant(rest));
+        break;
+      }
+      default: {
+        throw new Error(`Unknown keyword: ${keyword}`);
+      }
+    }
+  }
+  if (!diagram.length || Number.isNaN(diagram.length)) {
+    throw new Error("geneDiagram requires a `length` (protein length in amino acids)");
+  }
+  return diagram;
+}
+function layout(ast) {
+  const nodes = [];
+  const xDomain = [1, ast.length];
+  const xScale = (x) => MARGIN_X + INNER_WIDTH * (x - xDomain[0]) / (xDomain[1] - xDomain[0]);
+  const placedVariants = packVariants(ast.variants, xScale);
+  const maxVariantsStack = Math.max(1, ...placedVariants.map((p) => p.level + 1));
+  const stackHeight = FIRST_VARIANT_GAP_PX + maxVariantsStack * Y_OFFSET_PX;
+  const backboneY = MARGIN_Y + stackHeight;
+  nodes.push({
+    type: "line",
+    x1: xScale(xDomain[0]),
+    x2: xScale(xDomain[1]),
+    y1: backboneY,
+    y2: backboneY
+  });
+  nodes.push({
+    type: "text",
+    x: xScale(xDomain[0]),
+    y: backboneY + DOMAIN_LABEL_GAP_PX,
+    text: String(xDomain[0]),
+    anchor: "start",
+    baseline: "hanging"
+  });
+  nodes.push({
+    type: "text",
+    x: xScale(xDomain[1]),
+    y: backboneY + DOMAIN_LABEL_GAP_PX,
+    text: String(xDomain[1]),
+    anchor: "end",
+    baseline: "hanging"
+  });
+  for (const domain of ast.domains) {
+    const x = xScale(domain.start);
+    const width = xScale(domain.end) - xScale(domain.start);
+    nodes.push({
+      type: "group",
+      x,
+      y: backboneY,
+      children: [
+        {
+          type: "rect",
+          x: 0,
+          y: -BLOCK_HEIGHT_PX / 2,
+          width,
+          height: BLOCK_HEIGHT_PX,
+          fill: DOMAIN_FILL,
+          stroke: DOMAIN_STROKE
+        },
+        {
+          type: "text",
+          x: width / 2,
+          y: DOMAIN_LABEL_GAP_PX,
+          text: domain.label || "",
+          anchor: "middle",
+          baseline: "hanging"
+        }
+      ]
+    });
+  }
+  const levelY = (level) => backboneY - FIRST_VARIANT_GAP_PX - (level + 1) * Y_OFFSET_PX;
+  const columns = new Map;
+  for (const p of placedVariants) {
+    const col = columns.get(p.x);
+    if (col)
+      col.push(p);
+    else
+      columns.set(p.x, [p]);
+  }
+  const domainTopY = backboneY - BLOCK_HEIGHT_PX / 2;
+  const inDomain = (pos) => ast.domains.some((d) => pos >= d.start && pos <= d.end);
+  for (const [x, column] of columns) {
+    const headX = column[0].headX;
+    const topLevel = Math.max(...column.map((p) => p.level));
+    const anchorY = inDomain(column[0].variant.pos) ? domainTopY : backboneY;
+    nodes.push({
+      type: "path",
+      d: stemPath(x, anchorY, headX, levelY(topLevel)),
+      stroke: STEM_COLOR
+    });
+    for (const { variant, level } of column) {
+      const headY = levelY(level);
+      nodes.push({
+        type: "group",
+        x: 0,
+        y: 0,
+        children: [
+          {
+            type: "circle",
+            x: headX,
+            y: headY,
+            color: VARIANT_COLORS[variant.class],
+            radius: LOLLIPOP_RADIUS_PX,
+            stroke: HEAD_RING
+          },
+          {
+            type: "text",
+            x: headX + LABEL_GAP_PX,
+            y: headY + LOLLIPOP_RADIUS_PX,
+            text: variant.label
+          }
+        ]
+      });
+    }
+  }
+  const belowBackbone = DOMAIN_LABEL_GAP_PX + FONT_SIZE_PX;
+  return {
+    width: WIDTH_PX,
+    height: backboneY + belowBackbone + MARGIN_Y,
+    nodes
+  };
+}
+var geneDiagram = {
+  keyword: "geneDiagram",
+  parse,
+  layout
+};
+
+// src/modules/pedigreeDiagram.ts
+function coupleId(id1, id2) {
+  return [id1, id2].sort().join("-");
+}
+function parse2(rows) {
+  const diagram = {};
+  if (rows.length === 0) {
+    throw new Error("Empty DSL input");
+  }
+  for (const row of rows) {
+    const [keyword, ...rest] = tokenize(row);
+    switch (keyword) {
+      case "pedigreeDiagram": {
+        diagram.type = "pedigreeDiagram";
+        break;
+      }
+      case "couple": {
+        const [id1, id2] = rest;
+        if (!id1 || !id2) {
+          throw new Error(`Invalid couple definition: ${row}`);
+        }
+        if (!diagram.couples) {
+          diagram.couples = [{ id1, id2 }];
+        } else {
+          diagram.couples.push({ id1, id2 });
+        }
+        break;
+      }
+      case "node": {
+        const [id, sex, phenotype, genotype, childOf] = rest;
+        if (!id || !isSex(sex) || !isPhenotype(phenotype) || !isGenotype(genotype)) {
+          throw new Error(`Invalid node definition: ${row}`);
+        }
+        if (!diagram.nodes) {
+          diagram.nodes = [{ id, sex, phenotype, genotype, childOf }];
+        } else {
+          diagram.nodes.push({ id, sex, phenotype, genotype, childOf });
+        }
+        break;
+      }
+      default:
+        throw new Error(`Unknown keyword: ${keyword}`);
+    }
+  }
+  return diagram;
+}
+function isSex(value) {
+  return value === "male" || value === "female";
+}
+function isPhenotype(value) {
+  return value === "affected" || value === "unaffected" || value === "unknown";
+}
+function isGenotype(value) {
+  return value === "carrier" || value === "noncarrier" || value === "unknown";
+}
+var ROW_HEIGHT_PX = 60;
+var NODE_GAP_PX = 40;
+var SYMBOL_PX = 24;
+function layout2(diagram) {
+  const nodes = [];
+  const byId = new Map(diagram.nodes.map((n) => [n.id, n]));
+  const coupleById = new Map(diagram.couples.map((c) => [coupleId(c.id1, c.id2), c]));
+  const genMemo = new Map;
+  const gen = (id) => {
+    const cached = genMemo.get(id);
+    if (cached !== undefined)
+      return cached;
+    const node = byId.get(id);
+    if (!node?.childOf) {
+      genMemo.set(id, 0);
+      return 0;
+    }
+    const parents = coupleById.get(node.childOf);
+    if (!parents) {
+      throw new Error(`Node ${id} references unknown couple: ${node.childOf}`);
+    }
+    const g = 1 + Math.max(gen(parents.id1), gen(parents.id2));
+    genMemo.set(id, g);
+    return g;
+  };
+  const row = new Map;
+  for (const n of diagram.nodes)
+    row.set(n.id, gen(n.id));
+  for (const c of diagram.couples) {
+    const r = Math.max(row.get(c.id1) ?? 0, row.get(c.id2) ?? 0);
+    row.set(c.id1, r);
+    row.set(c.id2, r);
+  }
+  const childrenOf = new Map;
+  for (const n of diagram.nodes) {
+    if (!n.childOf)
+      continue;
+    (childrenOf.get(n.childOf) ?? childrenOf.set(n.childOf, []).get(n.childOf)).push(n.id);
+  }
+  const coupleByPartner = new Map;
+  for (const c of diagram.couples) {
+    coupleByPartner.set(c.id1, c);
+    coupleByPartner.set(c.id2, c);
+  }
+  const x = new Map;
+  let cursor = MARGIN_X;
+  const slot = () => {
+    const at = cursor;
+    cursor += SYMBOL_PX + NODE_GAP_PX;
+    return at;
+  };
+  const placed = new Set;
+  const placeNode = (id) => {
+    if (x.has(id))
+      return x.get(id);
+    placed.add(id);
+    const couple = coupleByPartner.get(id);
+    if (couple)
+      return placeCouple(couple);
+    const at = slot();
+    x.set(id, at);
+    return at;
+  };
+  const placeCouple = (c) => {
+    const key = coupleId(c.id1, c.id2);
+    if (x.has(key))
+      return x.get(key);
+    x.set(key, MARGIN_X);
+    const kids = childrenOf.get(key) ?? [];
+    const kidXs = kids.map(placeNode);
+    const half = (SYMBOL_PX + NODE_GAP_PX) / 2;
+    let mid;
+    if (kidXs.length > 0) {
+      mid = (Math.min(...kidXs) + Math.max(...kidXs)) / 2;
+      x.set(c.id1, mid - half);
+      x.set(c.id2, mid + half);
+    } else {
+      const p1x = slot();
+      const p2x = slot();
+      x.set(c.id1, p1x);
+      x.set(c.id2, p2x);
+      mid = (p1x + p2x) / 2;
+    }
+    x.set(key, mid);
+    return mid;
+  };
+  for (const c of diagram.couples) {
+    if ((row.get(c.id1) ?? 0) === Math.min(row.get(c.id1) ?? 0, row.get(c.id2) ?? 0)) {
+      placeCouple(c);
+    }
+  }
+  for (const n of diagram.nodes)
+    if (!placed.has(n.id))
+      placeNode(n.id);
+  const pos = new Map;
+  for (const n of diagram.nodes) {
+    pos.set(n.id, {
+      x: x.get(n.id) ?? MARGIN_X,
+      y: MARGIN_Y + (row.get(n.id) ?? 0) * ROW_HEIGHT_PX
+    });
+  }
+  for (const n of diagram.nodes) {
+    const p = pos.get(n.id);
+    nodes.push(symbol(n, p.x, p.y));
+  }
+  const SIB_BAR_DROP_PX = ROW_HEIGHT_PX / 2;
+  for (const c of diagram.couples) {
+    const a = pos.get(c.id1);
+    const b = pos.get(c.id2);
+    const [left, right] = a.x <= b.x ? [a, b] : [b, a];
+    const marriageY = left.y + SYMBOL_PX / 2;
+    nodes.push({
+      type: "line",
+      x1: left.x + SYMBOL_PX,
+      y1: marriageY,
+      x2: right.x,
+      y2: marriageY
+    });
+    const kids = childrenOf.get(coupleId(c.id1, c.id2)) ?? [];
+    if (kids.length === 0)
+      continue;
+    const midX = (left.x + SYMBOL_PX + right.x) / 2;
+    const barY = marriageY + SIB_BAR_DROP_PX;
+    const kidCenters = kids.map((kid) => pos.get(kid).x + SYMBOL_PX / 2);
+    nodes.push({ type: "line", x1: midX, y1: marriageY, x2: midX, y2: barY });
+    nodes.push({
+      type: "line",
+      x1: Math.min(midX, ...kidCenters),
+      y1: barY,
+      x2: Math.max(midX, ...kidCenters),
+      y2: barY
+    });
+    for (const kid of kids) {
+      const k = pos.get(kid);
+      nodes.push({ type: "line", x1: k.x + SYMBOL_PX / 2, y1: barY, x2: k.x + SYMBOL_PX / 2, y2: k.y });
+    }
+  }
+  const maxRow = Math.max(0, ...row.values());
+  return {
+    width: WIDTH_PX,
+    height: MARGIN_Y * 2 + maxRow * ROW_HEIGHT_PX + SYMBOL_PX,
+    nodes
+  };
+}
+function symbol(n, x, y) {
+  const affected = n.phenotype === "affected";
+  const carrier = n.genotype === "carrier";
+  const base = affected ? "black" : "white";
+  const r = SYMBOL_PX / 2;
+  const children = n.sex === "male" ? [{ type: "rect", x: 0, y: 0, width: SYMBOL_PX, height: SYMBOL_PX, fill: base }] : [{ type: "circle", x: r, y: r, radius: r, color: base, stroke: "black" }];
+  if (carrier && !affected) {
+    children.push(n.sex === "male" ? { type: "rect", x: 0, y: 0, width: r, height: SYMBOL_PX, fill: "black" } : { type: "path", d: `M ${r} 0 A ${r} ${r} 0 0 0 ${r} ${SYMBOL_PX} Z`, fill: "black", stroke: "black" });
+  }
+  return { type: "group", x, y, children };
+}
+var pedigreeDiagram = {
+  keyword: "pedigreeDiagram",
+  parse: parse2,
+  layout: layout2
+};
+
+// src/registry.ts
+var registry = {
+  geneDiagram,
+  pedigreeDiagram
+};
+
+// index.ts
+function parse3(dsl) {
+  const rows = splitRows(dsl);
+  const diagramKeyword = rows[0];
+  const module = diagramKeyword ? registry[diagramKeyword] : undefined;
+  if (!module) {
+    throw new Error(`Unknown diagram type: ${diagramKeyword ?? "(empty)"}`);
+  }
+  return module.parse(rows);
+}
+function render2(dsl) {
+  const rows = splitRows(dsl);
+  const diagramKeyword = rows[0];
+  if (!diagramKeyword) {
+    return null;
+  }
+  const module = registry[diagramKeyword];
+  if (!module) {
+    return null;
+  }
+  try {
+    const diagram = module.parse(rows);
+    const layout3 = module.layout(diagram);
+    return render(layout3);
+  } catch {
+    return null;
+  }
+}
+export {
+  splitRows,
+  render2 as render,
+  parse3 as parse
+};

package/dist/src/dsl.d.ts

@@ -0,0 +1,2 @@
+export declare function splitRows(text: string): string[];
+export declare function tokenize(text: string): string[];

package/dist/src/modules/geneDiagram.d.ts

@@ -0,0 +1,26 @@
+import type { DiagramModule, Layout } from "../types";
+export type GeneDiagram = {
+    type: "geneDiagram";
+    gene: string;
+    /** Protein length in amino acids. Defines the right end of the backbone. */
+    length: number;
+    domains: Domain[];
+    variants: Variant[];
+};
+export interface Domain {
+    /** First residue of the domain (amino-acid position, 1-based). */
+    start: number;
+    /** Last residue of the domain (amino-acid position, 1-based). */
+    end: number;
+    label?: string;
+}
+export interface Variant {
+    label: string;
+    /** Residue number the variant affects (amino-acid position, 1-based). */
+    pos: number;
+    class: VariantClass;
+}
+export type VariantClass = "missense" | "nonsense" | "frameshift" | "splice" | "synonymous";
+export declare function parse(rows: string[]): GeneDiagram;
+export declare function layout(ast: GeneDiagram): Layout;
+export declare const geneDiagram: DiagramModule<GeneDiagram>;

package/dist/src/modules/pedigreeDiagram.d.ts

@@ -0,0 +1,21 @@
+import type { DiagramModule, Layout } from "../types";
+export interface PedigreeDiagram {
+    type: "pedigreeDiagram";
+    couples: Couple[];
+    nodes: PedigreeNode[];
+}
+interface Couple {
+    id1: string;
+    id2: string;
+}
+interface PedigreeNode {
+    id: string;
+    sex: "male" | "female";
+    phenotype: "affected" | "unaffected" | "unknown";
+    genotype: "carrier" | "noncarrier" | "unknown";
+    childOf?: string;
+}
+export declare function parse(rows: string[]): PedigreeDiagram;
+export declare function layout(diagram: PedigreeDiagram): Layout;
+export declare const pedigreeDiagram: DiagramModule<PedigreeDiagram>;
+export {};

package/dist/src/registry.d.ts

@@ -0,0 +1,5 @@
+import type { GeneDiagram } from "./modules/geneDiagram";
+import type { PedigreeDiagram } from "./modules/pedigreeDiagram";
+import type { DiagramModule } from "./types";
+export type DiagramType = GeneDiagram["type"] | PedigreeDiagram["type"];
+export declare const registry: Record<DiagramType, DiagramModule<unknown>>;

package/dist/src/render.d.ts

@@ -0,0 +1,7 @@
+import type { Layout, LayoutNode, SVGString } from "./types";
+export declare const WIDTH_PX = 800;
+export declare const MARGIN_X = 10;
+export declare const MARGIN_Y = 14;
+export declare const INNER_WIDTH: number;
+export declare function renderNode(node: LayoutNode): string;
+export declare function render(layout: Layout): SVGString;

package/dist/src/types.d.ts

@@ -0,0 +1,59 @@
+import type { GeneDiagram } from "./modules/geneDiagram";
+export type Diagram = GeneDiagram;
+export type SVGString = string;
+export type Layout = {
+    width: number;
+    height: number;
+    nodes: LayoutNode[];
+};
+export type LayoutNode = Line | Rect | Text | Circle | Path | Group;
+type Path = {
+    type: "path";
+    d: string;
+    fill?: string;
+    stroke?: string;
+};
+type Circle = {
+    type: "circle";
+    x: number;
+    y: number;
+    radius: number;
+    color: string;
+    stroke?: string;
+};
+type Text = {
+    type: "text";
+    x: number;
+    y: number;
+    text: string;
+    baseline?: "hanging" | "base";
+    anchor?: "start" | "middle" | "end";
+};
+type Rect = {
+    type: "rect";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fill?: string;
+    stroke?: string;
+};
+type Line = {
+    type: "line";
+    x1: number;
+    x2: number;
+    y1: number;
+    y2: number;
+};
+type Group = {
+    type: "group";
+    x: number;
+    y: number;
+    children: LayoutNode[];
+};
+export interface DiagramModule<AST> {
+    keyword: string;
+    parse(rows: string[]): AST;
+    layout(ast: AST): Layout;
+}
+export {};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@gene-code/core",
+  "version": "0.0.1",
+  "description": "Core DSL parser and SVG renderer for gene-code diagrams.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/neznayer/gene-code.git",
+    "directory": "packages/core"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "bun build ./index.ts --outdir dist --target node --format esm && tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "typescript": "^5"
+  }
+}