tsdraft 0.3.0 → 0.4.0

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/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" | "linetype" | "duplicate-linetype" | "undefined-linetype" | "lineweight" | "layer-state" | "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. */
@@ -11,6 +12,14 @@ export interface Diagnostic {
     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. */
@@ -27,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,7 +1,8 @@
+import { callOf } from "./callsite.js";
 import { written } from "./format.js";
 import { layerAuditKey, layerKey } from "./layers.js";
 import { BUILT_IN_LINETYPES, builtInLinetype } from "./linetypes.js";
-import { arcIsWrittenAsPoint, arcProblem, layerColorProblem, layerFlagProblem, layerLinetypeProblem, layerNameProblem, layerStateProblem, layerTwinProblem, lineweightProblem, linetypeNameProblem, linetypeProblem, linetypeScaleProblem, R12_ONLY, magnitudeProblem, sizeProblem, textProblem, textWarning, undefinedLinetypeProblem, } from "./rules.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.
  *
@@ -13,6 +14,9 @@ import { arcIsWrittenAsPoint, arcProblem, layerColorProblem, layerFlagProblem, 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",
@@ -125,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.
@@ -172,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;
     }

package/dist/paper.d.ts

@@ -0,0 +1,33 @@
+import type { Units } from "./drawing.ts";
+import { type PaperLength, type Ratio } from "./rules.ts";
+/** A unit paper lengths are given in. */
+export type PaperUnit = "in" | "mm";
+/** The view a paper length is converted for. */
+export interface PaperScale<R extends number = number> {
+    /**
+     * How many times larger the model is than its plot, as a plain number: 96
+     * for 1/8" = 1'-0", 240 for 1" = 20', 50 for 1:50.
+     */
+    readonly ratio: Ratio<R>;
+    /** The drawing's units, as given to `createDrawing`. */
+    readonly units: Units;
+}
+/**
+ * Turns a length on paper into drawing units, for text, symbols and dashes
+ * that are sized by how large they plot. A 3/32 inch note on a sheet at
+ * 1/8" = 1'-0" is 9 inches in the model, which is 0.75 in a drawing in feet:
+ *
+ * ```ts
+ * fromPaper(3 / 32, "in", { ratio: 96, units: "ft" }); // 0.75
+ * ```
+ *
+ * A length or a ratio of 0 or less is a compile error when it is a literal.
+ *
+ * @param length - The length as it plots, greater than 0.
+ * @param unit - The unit of `length`: `"in"` or `"mm"`.
+ * @param view - The ratio the length plots at, and the drawing's units.
+ * @returns The length in drawing units.
+ * @throws When an argument is not one of the above, or when the result would
+ * be written as 0 at the 6 decimals tsdraft writes, or is 1e100 or more.
+ */
+export declare function fromPaper<L extends number, R extends number>(length: PaperLength<L>, unit: PaperUnit, view: PaperScale<R>): number;

package/dist/paper.js

@@ -0,0 +1,58 @@
+import { paperLengthProblem } from "./rules.js";
+/** Inches in one of each imperial unit, and millimetres in one of each metric unit. */
+const SIZES = {
+    in: ["imperial", 1],
+    ft: ["imperial", 12],
+    mm: ["metric", 1],
+    cm: ["metric", 10],
+    m: ["metric", 1000],
+};
+const MM_PER_INCH = 25.4;
+/**
+ * Turns a length on paper into drawing units, for text, symbols and dashes
+ * that are sized by how large they plot. A 3/32 inch note on a sheet at
+ * 1/8" = 1'-0" is 9 inches in the model, which is 0.75 in a drawing in feet:
+ *
+ * ```ts
+ * fromPaper(3 / 32, "in", { ratio: 96, units: "ft" }); // 0.75
+ * ```
+ *
+ * A length or a ratio of 0 or less is a compile error when it is a literal.
+ *
+ * @param length - The length as it plots, greater than 0.
+ * @param unit - The unit of `length`: `"in"` or `"mm"`.
+ * @param view - The ratio the length plots at, and the drawing's units.
+ * @returns The length in drawing units.
+ * @throws When an argument is not one of the above, or when the result would
+ * be written as 0 at the 6 decimals tsdraft writes, or is 1e100 or more.
+ */
+export function fromPaper(length, unit, view) {
+    // The arguments are read as unknown, because a parameter that failed its type is a message.
+    const paper = length;
+    const { ratio, units } = view;
+    const from = unit === "in" || unit === "mm" ? SIZES[unit] : undefined;
+    const to = typeof units === "string" && Object.hasOwn(SIZES, units) ? SIZES[units] : undefined;
+    if (!from)
+        throw new Error(`The paper unit must be "in" or "mm", not ${JSON.stringify(unit)}`);
+    if (!to)
+        throw new Error(`Unknown units: ${JSON.stringify(units)}`);
+    if (typeof paper !== "number" || !Number.isFinite(paper)) {
+        throw new Error("The paper length must be a finite number");
+    }
+    if (typeof ratio !== "number" || !Number.isFinite(ratio)) {
+        throw new Error("The ratio must be a finite number");
+    }
+    // Multiplying before dividing keeps 3/32 in at 96 in feet at exactly 0.75.
+    const model = paper * ratio * from[1];
+    const sameSystem = from[0] === to[0];
+    const converted = sameSystem
+        ? model
+        : from[0] === "imperial"
+            ? model * MM_PER_INCH
+            : model / MM_PER_INCH;
+    const result = converted / to[1];
+    const problem = paperLengthProblem(paper, ratio, result);
+    if (problem)
+        throw new Error(problem);
+    return result;
+}

package/dist/rules.d.ts

@@ -22,6 +22,8 @@ declare const COLOR = "A layer color must be an AutoCAD Color Index integer from
 declare const POSITIVE = "This value must be greater than 0";
 declare const WRITTEN_AS_ZERO = "This value is written as 0, because tsdraft writes 6 decimals. Use 0.000001 or more";
 declare const TOO_LARGE = "This value must be under 1e100, because AutoCAD reads only two exponent digits from DXF and would take 1e+100 for 1e+10";
+declare const PAPER_LENGTH = "The paper length must be greater than 0";
+declare const RATIO = "The ratio must be greater than 0";
 declare const TEXT_CONTROL = "Text must be a single line with no control characters";
 declare const TEXT_PRIVATE_USE = "Text cannot contain the private-use characters U+E800 to U+E8FF, because AutoCAD replaces them when it reads DXF";
 declare const R12_LINETYPES = "R12 drawings have no linetypes but Continuous, and no linetype scale. Use DXF version \"R2018\" for linetypes";
@@ -34,6 +36,9 @@ declare const LAYER_LINETYPE = "A layer's linetype cannot be ByLayer or ByBlock.
 declare const BUILT_IN = "Continuous, ByLayer and ByBlock are in every drawing and cannot be defined. AutoCAD keeps its own and drops the definition";
 declare const PATTERN_COUNT = "A linetype pattern has 2 to 12 lengths, or none for a solid line. AutoCAD's AUDIT reports a pattern of one length, and AutoCAD discards a drawing with a pattern of more than 12";
 declare const PATTERN_WRITTEN_AS_ZERO = "A dash or gap of this length is written as 0, because tsdraft writes 6 decimals, and would draw as a dot. Use 0 for a dot, or a length of 0.000001 or more";
+declare const ID_EMPTY = "An id cannot be empty";
+declare const ID_CHARS = "An id can only use the letters A to Z and a to z, digits, ., - and _";
+declare const ID_LENGTH = "An id cannot be longer than 64 characters";
 type ForbiddenChar = "<" | ">" | "/" | "\\" | '"' | ":" | ";" | "?" | "*" | "|" | "=" | "`" | "^" | "," | "\n" | "\r" | "\t";
 type Chars<S extends string, Found = never> = S extends `${infer C}${infer Rest}` ? Chars<Rest, Found | C> : Found;
 type R12Char = Chars<"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789$_-">;
@@ -54,6 +59,17 @@ export type LayerName<N extends string, V extends DxfVersion> = string extends N
  * layer names, apart from R12's, since R12 drawings have no linetypes.
  */
 export type LinetypeName<N extends string> = string extends N ? N : NameCheck<N, typeof LINETYPE_NAMES, N>;
+type IdChar = Exclude<R12Char, "$"> | ".";
+/** Walks the id one character at a time, counting, as `R12Name` walks a layer name. */
+type IdCheck<I extends string, Rest extends string = I, Count extends 0[] = []> = Count["length"] extends 65 ? typeof ID_LENGTH : Rest extends `${infer C}${infer Tail}` ? C extends IdChar ? IdCheck<I, Tail, [...Count, 0]> : typeof ID_CHARS : I;
+/**
+ * Resolves to `I` when it is a valid entity id, and to the error message otherwise: 1 to 64
+ * characters, each a letter A to Z or a to z, a digit, `.`, `-` or `_`. An id that is not a
+ * literal, such as `` `door-${n}` ``, passes the compiler: the first branch takes every type
+ * that is not a union of literals. It is checked when the code runs, as is whether the drawing
+ * already has the id.
+ */
+export type EntityId<I extends string> = {} extends Record<I, never> ? I : I extends "" ? typeof ID_EMPTY : IdCheck<I>;
 type Enumerate<N extends number, A extends number[] = []> = A["length"] extends N ? A[number] : Enumerate<N, [...A, A["length"]]>;
 /** AutoCAD Color Index: an integer from 1 to 255. */
 export type Aci = Exclude<Enumerate<256>, 0>;
@@ -74,6 +90,16 @@ type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
  * prints a third exponent digit as the writers do.
  */
 export type Positive<N extends number> = number extends N ? N : `${N}` extends `-${string}` | "0" ? typeof POSITIVE : WrittenAsZero<`${N}`> extends true ? typeof WRITTEN_AS_ZERO : `${N}` extends `${string}e+${Digit}${Digit}${Digit}` ? typeof TOO_LARGE : N;
+/**
+ * Resolves to `N` when it is greater than 0, and to `Message` otherwise. For a
+ * number that is worked with before anything is written, where `Positive`
+ * would refuse a small value for the 6 decimals.
+ */
+type AboveZero<N extends number, Message extends string> = number extends N ? N : `${N}` extends `-${string}` | "0" ? Message : N;
+/** Resolves to `N` when it is a length on paper, and to the error message otherwise. */
+export type PaperLength<N extends number> = AboveZero<N, typeof PAPER_LENGTH>;
+/** Resolves to `N` when it is a scale ratio, and to the error message otherwise. */
+export type Ratio<N extends number> = AboveZero<N, typeof RATIO>;
 type BuiltInName = Lowercase<(typeof BUILT_IN_LINETYPES)[number]>;
 /**
  * Resolves to `N` when it is a valid name for a new linetype, and to the error
@@ -131,9 +157,9 @@ export declare function linetypeNameProblem(name: string): string | undefined;
  * layers to AutoCAD and one duplicate name to AUDIT: `ΟΔΟΣ` and `οδος`,
  * `straße` and `strasse`, a composed é and a decomposed one, and a name with
  * and without a soft hyphen. `layerAuditKey` lists the kinds this covers,
- * which are those measured in AutoCAD and not all that AUDIT reports. Names
- * that are one layer to AutoCAD are not this function's concern. The rule
- * compares two names, so it has no type.
+ * which are not all that AUDIT reports. Names that are one layer to AutoCAD
+ * are not this function's concern. The rule compares two names, so it has no
+ * type.
  *
  * @param name - The name of the layer being checked.
  * @param other - The name of another layer in the drawing.
@@ -198,6 +224,17 @@ export declare function layerColorProblem(color: number): string | undefined;
  * @returns The problem, or undefined.
  */
 export declare function sizeProblem(value: number): string | undefined;
+/**
+ * Returns what is wrong with a paper length, the ratio it plots at, or the
+ * length in drawing units they give, or undefined when the result can be
+ * written. The result is a size, so it is held to the limits of `sizeProblem`.
+ *
+ * @param length - The length on paper, which must be a finite number.
+ * @param ratio - The scale ratio, which must be a finite number.
+ * @param result - The length in drawing units.
+ * @returns The problem, or undefined.
+ */
+export declare function paperLengthProblem(length: number, ratio: number, result: number): string | undefined;
 /**
  * Returns what is wrong with the size of a number a drawing holds, or
  * undefined when AutoCAD can read it. This goes for every number that is
@@ -231,6 +268,25 @@ export declare function arcProblem(startAngle: number, endAngle: number): string
  * @returns Whether the arc is written with no length.
  */
 export declare function arcIsWrittenAsPoint(startAngle: number, endAngle: number): boolean;
+/**
+ * Returns what is wrong with an entity id, or undefined when it is valid. It takes `unknown` so
+ * that `lint` can report a drawing built by hand with an id of the wrong type.
+ */
+export declare function idProblem(id: unknown): string | undefined;
+/** The form two ids are compared in: `Door-1` and `door-1` are one id. */
+export declare function idKey(id: string): string;
+/**
+ * Returns what is wrong with a second entity that has an id the drawing already has. The rule
+ * depends on the drawing, so it has no type.
+ *
+ * @param id - The id of the second entity.
+ * @param first - The id as the first entity spells it.
+ */
+export declare function duplicateIdProblem(id: string, first: string): string;
+/** Returns what is wrong with a drawing's format version, or undefined when tsdraft reads it. */
+export declare function formatProblem(format: unknown): string | undefined;
+/** A value of any type for a message: a string quoted, a number as it is, anything else by kind. */
+export declare function shown(value: unknown): string;
 /** Returns what is wrong with a single-line text value, or undefined when it is valid. */
 export declare function textProblem(value: string): string | undefined;
 /**