tsdraft 0.2.2 → 0.4.0

package/dist/index.js

@@ -1,4 +1,7 @@
 export { createDrawing, DrawingBuilder, sweep, } from "./drawing.js";
 export { toDXF } from "./dxf.js";
+export { fromJSON, toJSON } from "./json.js";
 export { DrawingError, lint } from "./lint.js";
+export { CENTER, DASHDOT, DASHED, DOT, HIDDEN, LINEWEIGHTS, PHANTOM } from "./linetypes.js";
+export { fromPaper } from "./paper.js";
 export { toSVG } from "./svg.js";

package/dist/json.d.ts

@@ -0,0 +1,21 @@
+import type { Drawing } from "./drawing.ts";
+/**
+ * Writes the drawing as canonical JSON: no white space, the keys of every object in code-unit
+ * order, and each number in the shortest form that reads back as the same number, with `-0`
+ * for negative zero. Two drawings that are equal give the same string, whatever order their
+ * keys were set in. A field that is `undefined` is left out.
+ *
+ * The drawing is written as it is and is not checked: `fromJSON` checks it when it is read.
+ * Throws when the drawing holds a value JSON cannot, such as `NaN`.
+ */
+export declare function toJSON(drawing: Drawing): string;
+/**
+ * Reads a drawing from JSON, as a string or as the value `JSON.parse` gives, which is returned
+ * as the drawing when it passes.
+ *
+ * It refuses a format version it does not know, a field or an entity kind it does not know, a
+ * missing field and a value of the wrong type, and then every error `lint` finds, so a drawing
+ * that was read has passed each check the builder makes. It throws a `DrawingError` whose
+ * diagnostics name each problem, with the rule `"format"` for the ones `lint` does not look for.
+ */
+export declare function fromJSON(json: unknown): Drawing;

package/dist/json.js

@@ -0,0 +1,244 @@
+import { DrawingError, lint } from "./lint.js";
+import { formatProblem, shown } from "./rules.js";
+/**
+ * Writes the drawing as canonical JSON: no white space, the keys of every object in code-unit
+ * order, and each number in the shortest form that reads back as the same number, with `-0`
+ * for negative zero. Two drawings that are equal give the same string, whatever order their
+ * keys were set in. A field that is `undefined` is left out.
+ *
+ * The drawing is written as it is and is not checked: `fromJSON` checks it when it is read.
+ * Throws when the drawing holds a value JSON cannot, such as `NaN`.
+ */
+export function toJSON(drawing) {
+    let out = "";
+    const write = (value) => {
+        switch (typeof value) {
+            case "number":
+                if (!Number.isFinite(value))
+                    break;
+                out += Object.is(value, -0) ? "-0" : value;
+                return;
+            case "string":
+                out += JSON.stringify(value);
+                return;
+            case "boolean":
+                out += value;
+                return;
+            case "object": {
+                if (value === null) {
+                    out += "null";
+                    return;
+                }
+                if (Array.isArray(value)) {
+                    out += "[";
+                    for (let i = 0; i < value.length; i++) {
+                        if (i > 0)
+                            out += ",";
+                        write(value[i]);
+                    }
+                    out += "]";
+                    return;
+                }
+                const fields = value;
+                let first = true;
+                for (const key of Object.keys(fields).sort()) {
+                    if (fields[key] === undefined)
+                        continue;
+                    out += `${first ? "{" : ","}${JSON.stringify(key)}:`;
+                    first = false;
+                    write(fields[key]);
+                }
+                out += first ? "{}" : "}";
+                return;
+            }
+        }
+        const shown = typeof value === "number" ? String(value) : typeof value;
+        throw new Error(`A drawing with a value of ${shown} cannot be written as JSON`);
+    };
+    write(drawing);
+    return out;
+}
+/**
+ * Reads a drawing from JSON, as a string or as the value `JSON.parse` gives, which is returned
+ * as the drawing when it passes.
+ *
+ * It refuses a format version it does not know, a field or an entity kind it does not know, a
+ * missing field and a value of the wrong type, and then every error `lint` finds, so a drawing
+ * that was read has passed each check the builder makes. It throws a `DrawingError` whose
+ * diagnostics name each problem, with the rule `"format"` for the ones `lint` does not look for.
+ */
+export function fromJSON(json) {
+    let value = json;
+    if (typeof json === "string") {
+        try {
+            value = JSON.parse(json);
+        }
+        catch (thrown) {
+            refuse([`The JSON cannot be parsed: ${thrown.message}`]);
+        }
+    }
+    if (!isRecord(value))
+        refuse([`The drawing ${PLAIN_OBJECT}`]);
+    // The fields of another format version cannot be judged, so its version is all that is said.
+    const format = formatProblem(Object.hasOwn(value, "format") ? value.format : undefined);
+    if (format)
+        refuse([format]);
+    const problems = [];
+    drawing(value, "", problems);
+    if (problems.length > 0)
+        refuse(problems);
+    const errors = lint(value).filter((d) => d.severity === "error");
+    if (errors.length > 0)
+        throw new DrawingError(errors);
+    return value;
+}
+function refuse(problems) {
+    throw new DrawingError(problems.map((message) => ({ rule: "format", severity: "error", message })));
+}
+const PLAIN_OBJECT = "must be a plain object, with no getter, setter or hidden field";
+/**
+ * True for a plain object whose fields are all its own data: no class or other object behind it
+ * to inherit a field from, no symbol or hidden key, which `toJSON` would not write, and no
+ * getter or setter, which could give another value each time it is read. No field is read.
+ */
+function isRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null)
+        return false;
+    for (const key of Reflect.ownKeys(value)) {
+        const field = Object.getOwnPropertyDescriptor(value, key);
+        if (typeof key !== "string" || !field?.enumerable || !("value" in field))
+            return false;
+    }
+    return true;
+}
+/**
+ * What is wrong with `value` as an array of plain data, or undefined: it must be an array with
+ * the methods of `Array`, each index its own plain value, and no key but its indexes. Stopping
+ * at the first empty slot keeps an array that is all slots, such as `new Array(1e9)`, cheap to
+ * refuse. No item is read.
+ */
+function arrayProblem(value, at) {
+    if (!Array.isArray(value) || !(value instanceof Array))
+        return `${at} must be an array`;
+    for (let i = 0; i < value.length; i++) {
+        const item = Object.getOwnPropertyDescriptor(value, i);
+        if (!item)
+            return `${at} has no item at index ${i}. An array cannot have empty slots`;
+        if (!("value" in item))
+            return `${at}[${i}] must be a plain value, not a getter or setter`;
+    }
+    // Its indexes and `length` are all the keys a plain array has.
+    return Reflect.ownKeys(value).length === value.length + 1
+        ? undefined
+        : `${at} must have no key but its indexes`;
+}
+function isNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+const string = (value, at, problems) => {
+    if (typeof value !== "string")
+        problems.push(`${at} must be a string`);
+};
+const number = (value, at, problems) => {
+    if (!isNumber(value))
+        problems.push(`${at} must be a number`);
+};
+const boolean = (value, at, problems) => {
+    if (typeof value !== "boolean")
+        problems.push(`${at} must be true or false`);
+};
+const numberOrName = (value, at, problems) => {
+    if (typeof value !== "string")
+        number(value, at, problems);
+};
+const point = (value, at, problems) => {
+    const pair = value;
+    if (arrayProblem(value, at) || pair.length !== 2 || !isNumber(pair[0]) || !isNumber(pair[1])) {
+        problems.push(`${at} must be a point, [x, y]`);
+    }
+};
+const oneOf = (...values) => (value, at, problems) => {
+    if (!values.includes(value)) {
+        problems.push(`${at} must be ${values.map(shown).join(" or ")}`);
+    }
+};
+const list = (item) => (value, at, problems) => {
+    const problem = arrayProblem(value, at);
+    if (problem)
+        problems.push(problem);
+    else
+        value.forEach((v, i) => item(v, `${at}[${i}]`, problems));
+};
+/**
+ * The fields of an object with exactly the fields of `T`. The two tables must name every field
+ * of `T`, so a field added to a type is a compile error here until the parser knows it.
+ */
+function fields(required, optional) {
+    const needed = required;
+    const known = { ...required, ...optional };
+    return (value, at, problems) => {
+        const label = at || "The drawing";
+        for (const key of Object.keys(needed)) {
+            if (!Object.hasOwn(value, key) || value[key] === undefined) {
+                problems.push(`${label}: the field "${key}" is missing`);
+            }
+        }
+        for (const [key, field] of Object.entries(value)) {
+            if (!Object.hasOwn(known, key)) {
+                problems.push(`${label}: unknown field ${JSON.stringify(key)}`);
+            }
+            else if (field !== undefined) {
+                known[key](field, at ? `${at}.${key}` : key, problems);
+            }
+        }
+    };
+}
+/** A plain object with the fields `check` knows. */
+const record = (check) => (value, at, problems) => {
+    if (isRecord(value))
+        check(value, at, problems);
+    else
+        problems.push(`${at} ${PLAIN_OBJECT}`);
+};
+const style = { id: string, linetype: string, lineweight: numberOrName };
+const kind = () => { };
+const ENTITIES = {
+    line: fields({ kind, layer: string, from: point, to: point }, style),
+    polyline: fields({ kind, layer: string, points: list(point), closed: boolean }, style),
+    circle: fields({ kind, layer: string, center: point, radius: number }, style),
+    arc: fields({ kind, layer: string, center: point, radius: number, startAngle: number, endAngle: number }, style),
+    text: fields({ kind, layer: string, at: point, height: number, value: string, rotation: number }, style),
+};
+const entity = (value, at, problems) => {
+    if (!isRecord(value)) {
+        problems.push(`${at} ${PLAIN_OBJECT}`);
+        return;
+    }
+    const named = Object.hasOwn(value, "kind") ? value.kind : undefined;
+    if (typeof named === "string" && Object.hasOwn(ENTITIES, named)) {
+        ENTITIES[named](value, at, problems);
+    }
+    else {
+        problems.push(`${at}: unknown entity kind ${shown(named)}`);
+    }
+};
+const drawing = fields({
+    format: () => { },
+    units: string,
+    dxf: oneOf("R12", "R2018"),
+    layers: list(record(fields({ name: string, color: number }, {
+        linetype: string,
+        lineweight: numberOrName,
+        off: boolean,
+        frozen: boolean,
+        locked: boolean,
+        plot: boolean,
+    }))),
+    entities: list(entity),
+}, {
+    linetypes: list(record(fields({ name: string, description: string, pattern: list(number) }, {}))),
+    linetypeScale: number,
+});

package/dist/layers.d.ts

@@ -38,7 +38,7 @@ export declare function layerKey(name: string): string;
  * error. Two names with the same key here are such a pair, unless they have
  * the same `layerKey` too.
  *
- * The key follows the kinds of pair measured in AutoCAD 2025:
+ * The key follows these kinds of pair:
  *
  * - A few single letters, such as σ and ς.
  * - A letter and the letters it stands for, such as ß and `ss`.

package/dist/layers.js

@@ -207,7 +207,7 @@ export function layerKey(name) {
  * error. Two names with the same key here are such a pair, unless they have
  * the same `layerKey` too.
  *
- * The key follows the kinds of pair measured in AutoCAD 2025:
+ * The key follows these kinds of pair:
  *
  * - A few single letters, such as σ and ς.
  * - A letter and the letters it stands for, such as ß and `ss`.
@@ -232,8 +232,7 @@ export function layerAuditKey(name) {
     // AUDIT does not report `coop` and `coop` with a soft hyphen after it as duplicates, though it
     // does report some other pairs that differ by a soft hyphen at the end. A mark for one at the
     // end keeps a name that ends with a soft hyphen apart from every name that does not. Two names
-    // that both end with one are compared like any others, as the pairs in `auditPairs` in
-    // `scripts/cad-check.ts` check.
+    // that both end with one are compared like any others.
     return name.endsWith(SOFT_HYPHEN) ? key + SOFT_HYPHEN : key;
 }
 /** Decomposes every composed character that AUDIT takes for its decomposed form. */

package/dist/linetypes.d.ts

@@ -0,0 +1,27 @@
+import type { Entity, Layer, Lineweight, Linetype } from "./drawing.ts";
+/** Every lineweight AutoCAD offers, in millimetres, from thinnest to widest. */
+export declare const LINEWEIGHTS: readonly Lineweight[];
+/** Dashes: 0.5 on, 0.25 off. */
+export declare const DASHED: Linetype;
+/** Short dashes, half the size of `DASHED`. */
+export declare const HIDDEN: Linetype;
+/** Long dash, short dash. */
+export declare const CENTER: Linetype;
+/** Long dash, two short dashes. */
+export declare const PHANTOM: Linetype;
+/** Dash, dot. */
+export declare const DASHDOT: Linetype;
+/** Dots, 0.25 apart. */
+export declare const DOT: Linetype;
+/** The linetypes every drawing has, in the spelling AutoCAD gives them. */
+export declare const BUILT_IN_LINETYPES: readonly ["ByBlock", "ByLayer", "Continuous"];
+/** The spelling AutoCAD gives a built-in linetype, or undefined for any other name. */
+export declare function builtInLinetype(name: string): (typeof BUILT_IN_LINETYPES)[number] | undefined;
+/** The linetype name a writer gives an entity, or undefined when it draws ByLayer. */
+export declare function entityLinetype(e: Entity): string | undefined;
+/** The linetype name a writer gives a layer. */
+export declare function layerLinetype(layer: Layer): string;
+/** A lineweight as DXF group 370 holds it: hundredths of a millimetre, or -1, -2 or -3. */
+export declare function lineweightCode(value: number | "ByLayer" | "ByBlock" | "Default"): number;
+/** The total length of a pattern, as AutoCAD stores it: the sum of the lengths, unsigned. */
+export declare function patternLength(pattern: readonly number[]): number;

package/dist/linetypes.js

@@ -0,0 +1,76 @@
+import { layerKey } from "./layers.js";
+/** Every lineweight AutoCAD offers, in millimetres, from thinnest to widest. */
+export const LINEWEIGHTS = [
+    0, 0.05, 0.09, 0.13, 0.15, 0.18, 0.2, 0.25, 0.3, 0.35, 0.4, 0.5, 0.53, 0.6, 0.7, 0.8, 0.9, 1,
+    1.06, 1.2, 1.4, 1.58, 2, 2.11,
+];
+// The linetypes plans use most, with the names, descriptions and patterns that AutoCAD 2025
+// loads from its acad.lin, so a drawing looks the same as one drafted by hand. The lengths are
+// in drawing units: scale them with the drawing's linetypeScale.
+/** Dashes: 0.5 on, 0.25 off. */
+export const DASHED = {
+    name: "DASHED",
+    description: "Dashed __ __ __ __ __ __ __ __ __ __ __ __ __ _",
+    pattern: [0.5, -0.25],
+};
+/** Short dashes, half the size of `DASHED`. */
+export const HIDDEN = {
+    name: "HIDDEN",
+    description: "Hidden __ __ __ __ __ __ __ __ __ __ __ __ __ _",
+    pattern: [0.25, -0.125],
+};
+/** Long dash, short dash. */
+export const CENTER = {
+    name: "CENTER",
+    description: "Center ____ _ ____ _ ____ _ ____ _ ____ _ ____",
+    pattern: [1.25, -0.25, 0.25, -0.25],
+};
+/** Long dash, two short dashes. */
+export const PHANTOM = {
+    name: "PHANTOM",
+    description: "Phantom ______  __  __  ______  __  __  ______",
+    pattern: [1.25, -0.25, 0.25, -0.25, 0.25, -0.25],
+};
+/** Dash, dot. */
+export const DASHDOT = {
+    name: "DASHDOT",
+    description: "Dash dot __ . __ . __ . __ . __ . __ . __ . __",
+    pattern: [0.5, -0.25, 0, -0.25],
+};
+/** Dots, 0.25 apart. */
+export const DOT = {
+    name: "DOT",
+    description: "Dot . . . . . . . . . . . . . . . . . . . . . .",
+    pattern: [0, -0.25],
+};
+/** The linetypes every drawing has, in the spelling AutoCAD gives them. */
+export const BUILT_IN_LINETYPES = ["ByBlock", "ByLayer", "Continuous"];
+/** The spelling AutoCAD gives a built-in linetype, or undefined for any other name. */
+export function builtInLinetype(name) {
+    const key = layerKey(name);
+    return BUILT_IN_LINETYPES.find((n) => layerKey(n) === key);
+}
+/** The linetype name a writer gives an entity, or undefined when it draws ByLayer. */
+export function entityLinetype(e) {
+    if (e.linetype === undefined)
+        return undefined;
+    return builtInLinetype(e.linetype) === "ByLayer" ? undefined : e.linetype;
+}
+/** The linetype name a writer gives a layer. */
+export function layerLinetype(layer) {
+    return layer.linetype ?? "Continuous";
+}
+/** A lineweight as DXF group 370 holds it: hundredths of a millimetre, or -1, -2 or -3. */
+export function lineweightCode(value) {
+    if (value === "ByLayer")
+        return -1;
+    if (value === "ByBlock")
+        return -2;
+    if (value === "Default")
+        return -3;
+    return Math.round(value * 100);
+}
+/** The total length of a pattern, as AutoCAD stores it: the sum of the lengths, unsigned. */
+export function patternLength(pattern) {
+    return pattern.reduce((sum, length) => sum + Math.abs(length), 0);
+}

package/dist/lint.d.ts

@@ -1,5 +1,6 @@
+import { type CallSite } from "./callsite.ts";
 import type { Drawing, DxfVersion } from "./drawing.ts";
-export type LintRule = "units" | "layer-name" | "duplicate-layer" | "layer-color" | "undefined-layer" | "geometry" | "text" | "zero-length";
+export type LintRule = "format" | "units" | "layer-name" | "duplicate-layer" | "layer-color" | "undefined-layer" | "linetype" | "duplicate-linetype" | "undefined-linetype" | "lineweight" | "layer-state" | "geometry" | "text" | "id" | "duplicate-id" | "zero-length";
 export interface Diagnostic {
     readonly rule: LintRule;
     /** An error means AutoCAD rejects, repairs or garbles the output. `toDXF` refuses to write it. */
@@ -7,8 +8,18 @@ export interface Diagnostic {
     readonly message: string;
     /** The layer the problem is in, when it is a layer problem. */
     readonly layer?: string;
+    /** The linetype the problem is in, when it is a problem with a linetype's definition. */
+    readonly linetype?: string;
     /** Index into `drawing.entities`, when it is an entity problem. */
     readonly entity?: number;
+    /** The `id` of the entity the problem is in, when it has one. */
+    readonly id?: string;
+    /**
+     * The call in the drawing's code that the problem comes from. `lint` gives the call that drew
+     * the entity when the drawing's builder recorded calls, and an error the builder throws gives
+     * the call that threw. Missing where the JavaScript engine has no stack to read.
+     */
+    readonly call?: CallSite;
 }
 export interface LintOptions {
     /** The DXF version to check against. Defaults to the drawing's own. */
@@ -25,15 +36,18 @@ export interface LintOptions {
 export declare function lint(drawing: Drawing, options?: LintOptions): Diagnostic[];
 /**
  * An error that refuses a drawing because of what `lint` found in it. `toDXF`
- * throws it when a drawing has lint errors for the version being written, and
- * other code can throw it to refuse a drawing for its own purpose. Its message
- * lists the first 10 problems and names no file format.
+ * throws it when a drawing has lint errors for the version being written, `fromJSON`
+ * when the JSON is not a drawing it can read, and the builder's `layer`, `linetype`
+ * and entity methods at a call that breaks a rule, with that one problem as the
+ * message. Other code can throw it to refuse a drawing for its own purpose. Its
+ * message lists the first 10 problems and names no file format.
  */
 export declare class DrawingError extends Error {
     /** Every problem the drawing was refused for, including those the message leaves out. */
     readonly diagnostics: readonly Diagnostic[];
     /**
      * @param diagnostics - The problems to refuse the drawing for, as `lint` returns them.
+     * @param message - Defaults to a list of the first 10 problems.
      */
-    constructor(diagnostics: readonly Diagnostic[]);
+    constructor(diagnostics: readonly Diagnostic[], message?: string);
 }

package/dist/lint.js

@@ -1,6 +1,8 @@
+import { callOf } from "./callsite.js";
 import { written } from "./format.js";
 import { layerAuditKey, layerKey } from "./layers.js";
-import { arcIsWrittenAsPoint, arcProblem, layerColorProblem, layerNameProblem, layerTwinProblem, magnitudeProblem, sizeProblem, textProblem, textWarning, } from "./rules.js";
+import { BUILT_IN_LINETYPES, builtInLinetype } from "./linetypes.js";
+import { arcIsWrittenAsPoint, arcProblem, duplicateIdProblem, formatProblem, idKey, idProblem, layerColorProblem, layerFlagProblem, layerLinetypeProblem, layerNameProblem, layerStateProblem, layerTwinProblem, lineweightProblem, linetypeNameProblem, linetypeProblem, linetypeScaleProblem, R12_ONLY, magnitudeProblem, sizeProblem, textProblem, textWarning, undefinedLinetypeProblem, } from "./rules.js";
 /**
  * Checks a drawing against the rules AutoCAD enforces when it opens DXF.
  *
@@ -12,6 +14,9 @@ import { arcIsWrittenAsPoint, arcProblem, layerColorProblem, layerNameProblem, l
 export function lint(drawing, options = {}) {
     const version = options.version ?? drawing.dxf;
     const out = [];
+    const format = formatProblem(drawing.format);
+    if (format)
+        out.push({ rule: "format", severity: "error", message: format });
     if (!["in", "ft", "mm", "cm", "m"].includes(drawing.units)) {
         out.push({
             rule: "units",
@@ -19,6 +24,52 @@ export function lint(drawing, options = {}) {
             message: `Unknown units: ${JSON.stringify(drawing.units)}`,
         });
     }
+    const r12 = version === "R12";
+    const scale = drawing.linetypeScale;
+    if (scale !== undefined && (r12 ? scale !== 1 : linetypeScaleProblem(scale))) {
+        const problem = r12 ? R12_ONLY.linetypes : linetypeScaleProblem(scale);
+        out.push({ rule: "linetype", severity: "error", message: `linetypeScale: ${problem}` });
+    }
+    // AutoCAD compares linetype names as it compares layer names, and AUDIT reports a twin of a
+    // built-in linetype as it reports any other.
+    const linetypes = new Set();
+    const linetypesAudited = new Map(BUILT_IN_LINETYPES.map((name) => [layerAuditKey(name), name]));
+    for (const linetype of drawing.linetypes ?? []) {
+        const error = (rule, message) => out.push({ rule, severity: "error", message, linetype: linetype.name });
+        const label = `Linetype ${JSON.stringify(linetype.name)}`;
+        if (r12) {
+            error("linetype", `${label}: ${R12_ONLY.linetypes}`);
+            continue;
+        }
+        const problem = linetypeProblem(linetype.name, linetype.description, linetype.pattern);
+        if (problem)
+            error("linetype", `${label}: ${problem}`);
+        if (typeof linetype.name !== "string")
+            continue;
+        const key = layerKey(linetype.name);
+        const auditKey = layerAuditKey(linetype.name);
+        const twin = layerTwinProblem(linetype.name, linetypesAudited.get(auditKey) ?? linetype.name, "linetype");
+        if (linetypes.has(key)) {
+            error("duplicate-linetype", `${label} is defined twice. CAD ignores case in linetype names and keeps the first`);
+        }
+        else if (twin) {
+            error("duplicate-linetype", `${label}: ${twin}`);
+        }
+        linetypes.add(key);
+        if (!linetypesAudited.has(auditKey))
+            linetypesAudited.set(auditKey, linetype.name);
+    }
+    /** What is wrong with a reference to a linetype, which AutoCAD discards a drawing over. */
+    const missing = (name) => {
+        if (typeof name !== "string")
+            return "a linetype is named by a string";
+        const problem = linetypeNameProblem(name);
+        if (problem)
+            return `Linetype ${JSON.stringify(name)}: ${problem}`;
+        return builtInLinetype(name) || linetypes.has(layerKey(name))
+            ? undefined
+            : undefinedLinetypeProblem(name);
+    };
     // AutoCAD looks layers up by one form of their names, and AUDIT compares another.
     const seen = new Set();
     const audited = new Map();
@@ -30,6 +81,38 @@ export function lint(drawing, options = {}) {
         const colorProblem = layerColorProblem(layer.color);
         if (colorProblem)
             error("layer-color", `Layer ${JSON.stringify(layer.name)}: ${colorProblem}`);
+        const label = `Layer ${JSON.stringify(layer.name)}`;
+        if (layer.linetype !== undefined) {
+            const name = layer.linetype;
+            if (r12) {
+                if (typeof name !== "string" || builtInLinetype(name) !== "Continuous") {
+                    error("linetype", `${label}: ${R12_ONLY.linetypes}`);
+                }
+            }
+            else {
+                const absent = missing(name);
+                if (absent)
+                    error("undefined-linetype", `${label}: ${absent}`);
+                const problem = typeof name === "string" ? layerLinetypeProblem(name) : undefined;
+                if (problem)
+                    error("linetype", `${label}: ${problem}`);
+            }
+        }
+        if (layer.lineweight !== undefined) {
+            const problem = lineweightProblem(layer.lineweight, "layer") ??
+                (r12 && layer.lineweight !== "Default" ? R12_ONLY.lineweights : undefined);
+            if (problem)
+                error("lineweight", `${label}: ${problem}`);
+        }
+        for (const state of ["off", "frozen", "locked", "plot"]) {
+            const flagProblem = layerFlagProblem(state, layer[state]);
+            if (flagProblem)
+                error("layer-state", `${label}: ${flagProblem}`);
+        }
+        const states = layer.off || layer.frozen || layer.locked || layer.plot === false;
+        const stateProblem = r12 && states ? R12_ONLY.layerStates : layerStateProblem(layer.name, layer.frozen);
+        if (stateProblem)
+            error("layer-state", `${label}: ${stateProblem}`);
         const key = layerKey(layer.name);
         const auditKey = layerAuditKey(layer.name);
         const twinProblem = layerTwinProblem(layer.name, audited.get(auditKey) ?? layer.name);
@@ -46,8 +129,31 @@ export function lint(drawing, options = {}) {
     if (!seen.has("0")) {
         out.push({ rule: "undefined-layer", severity: "error", message: 'Layer "0" is missing' });
     }
+    /** The first spelling of each id, by `idKey`. */
+    const ids = new Map();
     drawing.entities.forEach((entity, index) => {
-        const add = (rule, severity, problem) => out.push({ rule, severity, message: `${entity.kind} #${index}: ${problem}`, entity: index });
+        const id = entity.id;
+        const add = (rule, severity, problem) => {
+            const call = callOf(drawing.entities, index);
+            out.push({
+                rule,
+                severity,
+                message: `${entity.kind} #${index}: ${problem}`,
+                entity: index,
+                ...(typeof id === "string" ? { id } : {}),
+                ...(call ? { call } : {}),
+            });
+        };
+        if (id !== undefined) {
+            const problem = idProblem(id);
+            const first = problem ? undefined : ids.get(idKey(id));
+            if (problem)
+                add("id", "error", problem);
+            else if (first !== undefined)
+                add("duplicate-id", "error", duplicateIdProblem(id, first));
+            else
+                ids.set(idKey(id), id);
+        }
         if (!seen.has(layerKey(entity.layer))) {
             // AutoCAD adds a layer for a name it does not know. When AUDIT takes that name for a
             // declared layer's, it then reports the new layer as a duplicate of it.
@@ -57,6 +163,22 @@ export function lint(drawing, options = {}) {
                 : "";
             add("undefined-layer", "error", `layer ${JSON.stringify(entity.layer)} is not defined${hint}`);
         }
+        if (entity.linetype !== undefined) {
+            const name = entity.linetype;
+            const problem = r12
+                ? typeof name === "string" && builtInLinetype(name) === "ByLayer"
+                    ? undefined
+                    : R12_ONLY.entityStyle
+                : missing(name);
+            if (problem)
+                add(r12 ? "linetype" : "undefined-linetype", "error", problem);
+        }
+        if (entity.lineweight !== undefined) {
+            const problem = lineweightProblem(entity.lineweight, "entity") ??
+                (r12 && entity.lineweight !== "ByLayer" ? R12_ONLY.entityStyle : undefined);
+            if (problem)
+                add("lineweight", "error", problem);
+        }
         const problems = geometryProblems(entity);
         for (const problem of problems)
             add("geometry", "error", problem);
@@ -77,21 +199,24 @@ export function lint(drawing, options = {}) {
 }
 /**
  * An error that refuses a drawing because of what `lint` found in it. `toDXF`
- * throws it when a drawing has lint errors for the version being written, and
- * other code can throw it to refuse a drawing for its own purpose. Its message
- * lists the first 10 problems and names no file format.
+ * throws it when a drawing has lint errors for the version being written, `fromJSON`
+ * when the JSON is not a drawing it can read, and the builder's `layer`, `linetype`
+ * and entity methods at a call that breaks a rule, with that one problem as the
+ * message. Other code can throw it to refuse a drawing for its own purpose. Its
+ * message lists the first 10 problems and names no file format.
  */
 export class DrawingError extends Error {
     /** Every problem the drawing was refused for, including those the message leaves out. */
     diagnostics;
     /**
      * @param diagnostics - The problems to refuse the drawing for, as `lint` returns them.
+     * @param message - Defaults to a list of the first 10 problems.
      */
-    constructor(diagnostics) {
+    constructor(diagnostics, message) {
         const count = diagnostics.length === 1 ? "1 problem" : `${diagnostics.length} problems`;
         const shown = diagnostics.slice(0, 10).map((d) => `- ${d.message}`);
         const more = diagnostics.length > 10 ? [`- and ${diagnostics.length - 10} more`] : [];
-        super([`The drawing has ${count}:`, ...shown, ...more].join("\n"));
+        super(message ?? [`The drawing has ${count}:`, ...shown, ...more].join("\n"));
         this.name = "DrawingError";
         this.diagnostics = diagnostics;
     }