tsdraft 0.2.0 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,90 @@
 # Changelog
 
+## 0.2.2
+
+Found by opening tsdraft's output in AutoCAD 2025.
+
+- Fixed: AutoCAD keeps two layers such as `straße` and `STRASSE` apart, but its
+  `AUDIT` reports them as a duplicate name. `lint` now reports the second layer
+  as a duplicate, and the builder throws at the `layer()` call. It does so for
+  the kinds of pair measured in AutoCAD, in either letter case and inside longer
+  names:
+  - a letter and the letters it stands for, such as `ß` and `ss`, `æ` and `ae`,
+    `œ` and `oe`, `ij` and `ij`, `fi` and `fi`, `dž` and `dž`, and `þ` and `th`;
+  - a composed character and its decomposed form, such as `é`;
+  - a name with a soft hyphen inside it or in front of it and the same name
+    without.
+
+  This is not all that `AUDIT` reports. The README lists what is covered and
+  what is left out.
+
+- When an entity names its layer by the other spelling of such a pair, the
+  undefined-layer error now says which declared layer AutoCAD does not take it
+  for. AutoCAD adds a layer for the entity, and `AUDIT` reports a duplicate name.
+- `pnpm test:cad` checks each kind of pair against AutoCAD, and 600 longer names
+  beside respellings of themselves.
+
+## 0.2.1
+
+Every fix below was found by opening tsdraft's output in AutoCAD 2025.
+
+- Fixed: text holding `\U+XXXX` or `\M+NXXXX` came out in AutoCAD as the
+  character those escapes stand for, so `\U+00B0` became a degree sign and
+  `\U+000A` put a line feed inside a single-line text. Both DXF versions now
+  write such a backslash so that AutoCAD holds the text as the drawing has it
+  when it opens the file. AutoCAD decodes the text after all once it has saved
+  the drawing itself and opened it again: `\M+NXXXX` after a save as DWG, and
+  `\U+XXXX` too after a save as DXF.
+- Fixed: a size too small for the 6 decimals tsdraft writes was written as 0.
+  AutoCAD gave such a text its default height, and held such a circle or arc
+  with radius 0. A radius, text height or rectangle size that would be written
+  as 0 is now an error, in the compiler for a literal and when the code runs.
+  `rect()` also throws when a side is lost because two corners round together.
+- Fixed: AutoCAD reads only two exponent digits from DXF, so it took a number
+  written as `1e+100` for `1e+10`, with no `AUDIT` error. A coordinate, size or
+  text rotation of 1e100 or more is now an error, in the compiler for a size
+  written as a literal and when the code runs. The R2018 writer also caps the
+  extents and the view height it works out, which could pass 1e100 for a
+  drawing whose own numbers are all smaller.
+- Fixed: an arc within 0.000001 degrees of a full turn was written with equal
+  angles, which AutoCAD holds as an arc of no length. It is now an error. An arc
+  angle that rounds up to 360 is written as 0.
+- Fixed: `toDXF` wrote layer `0` wherever the drawing listed it, and `AUDIT`
+  reported "Layer zero name found at incorrect index" when another layer came
+  first. Layer `0` is now written first.
+- Fixed: `lint` matched layer names with JavaScript's `toLowerCase()`, which
+  AutoCAD does not use. It accepted an entity on `οδος` for a layer `ΟΔΟΣ`,
+  where AutoCAD makes a second layer. `lint` and the builder now compare names
+  as AutoCAD does. The README lists the pairs that differ.
+- Fixed: two layers such as `ΟΔΟΣ` and `οδος`, which AutoCAD keeps apart but
+  its `AUDIT` reports as a duplicate name, are now an error.
+- Fixed: AutoCAD discarded a drawing whose layer name had a zero-width space,
+  another invisible formatting character, a letterlike symbol such as the ohm
+  sign U+2126, or a Glagolitic, Coptic, Tifinagh, Georgian Supplement, Latin
+  Extended-C or Ethiopic Extended letter. Those names are now errors, in the
+  compiler for a literal and when the code runs. The README lists them.
+- Fixed: `lint` threw a `RangeError` on a polyline of about 100,000 points or
+  more.
+- Fixed: a layer name that starts or ends with a no-break space, or another
+  space outside ASCII, threw when the code ran, though the compiler accepted
+  the literal and AutoCAD accepts the name. Only an ASCII space is refused now.
+- Fixed: AutoCAD replaced the private-use characters U+E800 to U+E8FF in text
+  and layer names. They are now errors.
+- Fixed: `toSVG` drew nothing for an arc so close to a full turn that its ends
+  rounded to one point, and ignored a layer's color when an entity spelled the
+  layer's name in another case.
+- Changed: a `DrawingError` message starts "The drawing has 3 problems:" and no
+  longer names DXF, because code other than `toDXF` uses it to refuse a drawing.
+- Changed: `lint` messages for a bad radius or height read "radius: This value
+  must be greater than 0", the wording the compiler uses for a literal.
+- `lint` warns about a polyline or an arc with no length, as it does for a line,
+  and about a line, polyline or arc that loses its length to rounding.
+- `lint` warns about text that contains `%%`, which AutoCAD stores as written
+  but draws as a control code: `%%d` is drawn as a degree sign.
+- `pnpm test:cad` covers each fix above, and checks every character `lint`
+  accepts in text and in layer names, and each form of number the writers
+  print, against AutoCAD.
+
 ## 0.2.0
 
 0.1.1 was never published, so its changes ship here too.

package/README.md

@@ -46,6 +46,12 @@ Coordinates are in drawing units with Y pointing up, as in CAD. Angles are in
 degrees, counterclockwise from +X. Layer colors are AutoCAD Color Index numbers.
 Entities go on layer `0` unless they are drawn inside a `layer()` callback.
 
+Numbers are written with 6 decimals, in DXF and in SVG. The checks below judge
+a drawing as it will be written, so a size too small to survive the rounding is
+an error and a line that rounds down to a point is a warning. Every number must
+also be under 1e100 in size. AutoCAD reads only two exponent digits from DXF, so
+it would take `1e+100` for `1e+10` and report nothing.
+
 ## DXF versions
 
 A drawing is written for one DXF version. `createDrawing()` targets R12, the
@@ -98,15 +104,131 @@ The rules:
 - Layer names cannot be empty, start or end with a space, or contain a line
   break or any of ``< > / \ " : ; ? * | = ` ^ ,``. R12 names have the tighter
   limits in the table above.
+- Layer names cannot contain the other characters AutoCAD refuses in a name. It
+  discards the drawing over any of them, and they are listed under
+  [Layer name characters](#layer-name-characters).
 - `wall` and `WALL` are the same layer, as in CAD. The first spelling is kept.
+  tsdraft compares names the way AutoCAD does, which is not the way JavaScript
+  does: see [Layer names and case](#layer-names-and-case).
 - Layer colors are whole numbers from 1 to 255.
-- Radii, text heights and rectangle sizes are greater than 0.
+- Radii, text heights and rectangle sizes are greater than 0, and large enough
+  not to be written as 0. Anything from 0.000001 up is safe. AutoCAD gives text
+  of height 0 its default height.
 - Text is a single line. It cannot contain emoji or other characters above
-  U+FFFF, because AutoCAD cannot read them from DXF.
-- Arc angles are stored from 0 up to 360, so -90 becomes 270.
-
-`lint` also returns warnings, such as a line with no length. Warnings do not
-stop an export.
+  U+FFFF, because AutoCAD cannot read them from DXF, or the private-use
+  characters U+E800 to U+E8FF, which AutoCAD replaces.
+- Coordinates, sizes and text rotations are under 1e100 in size, because
+  AutoCAD reads only two exponent digits from DXF.
+- Arc angles are stored from 0 up to 360, so -90 becomes 270. An arc cannot come
+  within 0.000001 degrees of a full turn, because its two angles would be
+  written the same and AutoCAD holds such an arc as having no length. Draw a
+  circle instead.
+
+`lint` also returns warnings. Warnings do not stop an export. They are:
+
+- A line, a polyline or an arc that has no length, or has none once its numbers
+  are rounded.
+- Text that contains `%%`. AutoCAD stores the text as written but reads `%%` as
+  the start of a control code when it draws it: `%%d` is drawn as a degree sign
+  and `%%%` as one percent sign.
+
+`toDXF` throws a `DrawingError` for errors only. Its `diagnostics` property holds
+them, and other code may throw one to refuse a drawing for its own reasons.
+
+### Text
+
+When AutoCAD opens tsdraft's DXF, it holds each text exactly as the drawing has
+it. tsdraft escapes what DXF would otherwise read as something else: a caret,
+and a backslash that starts `\U+XXXX` or `\M+NXXXX`, which AutoCAD decodes into
+a character. A text `\U+00B0` reaches AutoCAD as those seven characters and not
+as a degree sign. Write the character itself, `°`, to get the character.
+
+That lasts until AutoCAD saves the drawing, because AutoCAD does not escape these
+sequences in what it writes. After it saves as DWG and opens the file again, a
+text `\M+18140` holds the character U+3000. After it saves as DXF and opens
+that, `\U+00B0` holds a degree sign as well. tsdraft cannot change this.
+
+### Layer names and case
+
+AutoCAD lower-cases a layer name one character at a time, from a table of its
+own that is older and smaller than Unicode's. An entity on `mixedcase`, `café`,
+`αβγ` or `СЛОЙ` goes on a layer declared as `MixedCase`, `CAFÉ`, `ΑΒΓ` or `Слой`,
+and `lint` accepts it. AutoCAD does not pair these, and `lint` reports the
+entity's layer as undefined:
+
+- `ΟΔΟΣ` and `οδος`, because of the final sigma `ς`. `οδοσ` does match.
+- `STRASSE` and `straße`, and `TITLE` and `tıtle` with a dotless `ı`.
+- `Ÿ` and `ÿ`, `İ` and `i`, and the title-case digraphs such as `Dž`.
+- Georgian, Cherokee and most other letters that gained a case after Unicode
+  5.1.
+
+Where `AUDIT` would take the entity's spelling for the declared layer's, as it
+does for `STRASSE` and `straße`, the message says so. AutoCAD adds a layer for
+the entity, and `AUDIT` then reports a duplicate name.
+
+### Layer names that AUDIT calls duplicates
+
+AutoCAD's `AUDIT` compares layer names another way than AutoCAD looks them up.
+It reports "Duplicate name" for some pairs of layers that AutoCAD keeps as two.
+`lint` reports the second layer of such a pair as a duplicate, which is an
+error, for these kinds of pair. Each kind holds in either letter case and
+inside a longer name, so `Hauptstraße 12` and `HAUPTSTRASSE 12` are a pair.
+
+- Single letters: `σ` and `ς`, `Ÿ` and `ÿ`, `ß` and `ẞ`, a title-case digraph
+  such as `Dž` and `dž`, and a few others.
+- A letter and the letters it stands for: `ß` and `ss`, `æ` and `ae`, `œ` and
+  `oe`, `ij` and `ij`, `þ` and `th`, `dž` and `dž`, `lj` and `lj`, `nj` and `nj`,
+  `dz` and `dz`, the ligatures `ff`, `fi`, `fl`, `ffi`, `ffl` and `st`, and `ȸ`, `ȹ`,
+  `ʪ`, `ʫ`, `ꜳ`, `ꜵ`, `ꜷ`, `ꜹ`, `ꜽ`, `ꝏ` and `ᴂ`.
+- A composed character and its decomposed form, such as `é` and an `e` with a
+  combining acute accent, with its marks in any order Unicode counts as the
+  same, such as a dot below before or after a circumflex. Hangul syllables are
+  an exception, and so are 40 Arabic, Indic, Myanmar, kana, Hebrew and CJK
+  compatibility characters: `AUDIT` keeps those apart from their decomposed
+  forms.
+- A name with a soft hyphen, U+00AD, inside it or in front of it, and the same
+  name without.
+
+This is what was measured in AutoCAD 2025. It is not AutoCAD's whole comparison,
+so a drawing that passes `lint` can still get a "Duplicate name" from `AUDIT`.
+The rule is kept narrow so that it does not go the other way: in over 20,000
+pairs tried, `lint` reported none that `AUDIT` accepts. What it leaves out:
+
+- A name that ends with a soft hyphen and the same name without it, and a soft
+  hyphen in front of a combining mark or a Hangul jamo. `AUDIT` reports some of
+  those pairs and not others. It does not report `coop` and `coop` followed by a
+  soft hyphen. Two names that both end with a soft hyphen are compared like any
+  others.
+- Compatibility characters that `AUDIT` takes for their plain forms, such as a
+  modifier letter `ʰ` and `h`, `㎏` and `kg`, and Arabic presentation forms.
+- Characters that `AUDIT` cannot tell from an unassigned one, such as `Ԥ`,
+  U+0524, and `Ꙡ`, U+A660. Two names that differ only in such characters are
+  duplicates to it.
+
+### Layer name characters
+
+AutoCAD refuses these characters in a layer name, so `lint` does too. Over any
+of them but the last row's, AutoCAD discards the whole drawing. All are outside
+ASCII, so they only concern R2018 drawings.
+
+| Characters                                                                 | What they are                                              |
+| -------------------------------------------------------------------------- | ---------------------------------------------------------- |
+| U+0080 to U+009F                                                           | C1 control characters                                      |
+| U+0600 to U+0603, U+06DD, U+070F, U+17B4, U+17B5                           | Arabic, Syriac and Khmer formatting characters             |
+| U+200B to U+200F, U+202A to U+202E, U+2060 to U+2064, U+206A to U+206F     | Zero-width spaces and joiners, and text direction controls |
+| U+FEFF, U+FFF9 to U+FFFB                                                   | The byte order mark and annotation characters              |
+| U+2071, U+207F, U+2090 to U+2094                                           | Superscript and subscript letters                          |
+| Letters in U+2102 to U+214E, such as `ℓ`, `ℕ`, the ohm sign and the kelvin | Letterlike symbols. Use the Greek `Ω`, U+03A9, for ohms.   |
+| U+2180 to U+2188                                                           | Roman numeral characters                                   |
+| U+2C00 to U+2C5E, except U+2C2F                                            | Glagolitic                                                 |
+| U+2C60 to U+2C7D, except U+2C70                                            | Latin Extended-C                                           |
+| U+2C80 to U+2CE4                                                           | Coptic                                                     |
+| U+2D00 to U+2D25                                                           | Georgian Supplement                                        |
+| U+2D30 to U+2D65, U+2D6F                                                   | Tifinagh                                                   |
+| Letters in U+2D80 to U+2DDE                                                | Ethiopic Extended                                          |
+| U+E800 to U+E8FF                                                           | Private use. AutoCAD replaces these and keeps the drawing. |
+
+`src/layers.ts` has the exact list.
 
 ## Development
 
@@ -124,7 +246,8 @@ pnpm example   # writes a site plan to examples/out/ as DXF and SVG
 that has AutoCAD. Each test drawing runs in AutoCAD's headless console, which
 runs `AUDIT` and saves the drawing back as DXF. The script then compares that
 file with what was drawn. Run it after any change to a DXF writer, because
-AutoCAD rejects files that DXF parsing libraries accept.
+AutoCAD rejects files that DXF parsing libraries accept. Some of its cases write
+a file `toDXF` would refuse, to show that AutoCAD does what the rule says.
 
 `pnpm test:package` packs the package, installs the tarball into a throwaway
 project and checks that it type-checks and runs there. `pnpm build` compiles

package/dist/drawing.d.ts

@@ -105,6 +105,10 @@ export declare class DrawingBuilder<V extends DxfVersion = "R12"> {
      * Arc from `startAngle` counterclockwise to `endAngle`. Angles are stored
      * from 0 up to 360, so -90 becomes 270, because AutoCAD's AUDIT rejects
      * angles outside that range.
+     *
+     * Angles are written with 6 decimals. An arc within 0.000001 degrees of a
+     * full turn would be written with equal angles, which AutoCAD holds as an
+     * arc of no length, so it throws: draw a circle instead.
      */
     arc<R extends number>(center: Point, radius: Positive<R>, startAngle: number, endAngle: number): this;
     text<H extends number = number>(at: Point, value: string, options?: TextOptions<H>): this;

package/dist/drawing.js

@@ -1,4 +1,6 @@
-import { layerColorProblem, layerNameProblem, textProblem, } from "./rules.js";
+import { fmt, written } from "./format.js";
+import { layerAuditKey, layerKey } from "./layers.js";
+import { arcProblem, layerColorProblem, magnitudeProblem, layerNameProblem, layerTwinProblem, sizeProblem, textProblem, } from "./rules.js";
 const UNITS = ["in", "ft", "mm", "cm", "m"];
 const DXF_VERSIONS = ["R12", "R2018"];
 /**
@@ -12,8 +14,10 @@ const DXF_VERSIONS = ["R12", "R2018"];
 export class DrawingBuilder {
     units;
     dxf;
-    /** Keyed by lower-cased name, because CAD ignores case in layer names. */
+    /** Keyed by `layerKey`, because AutoCAD ignores case in layer names. */
     #layers = new Map([["0", { name: "0", color: 7 }]]);
+    /** The first layer name for each `layerAuditKey`, to find names AUDIT would call duplicates. */
+    #audited = new Map([["0", "0"]]);
     #entities = [];
     #current = "0";
     constructor(options = {}) {
@@ -37,14 +41,20 @@ export class DrawingBuilder {
         const nameProblem = layerNameProblem(requested, this.dxf);
         if (nameProblem)
             throw new Error(`Layer ${JSON.stringify(requested)}: ${nameProblem}`);
-        const key = requested.toLowerCase();
+        const key = layerKey(requested);
         const existing = this.#layers.get(key);
+        const auditKey = layerAuditKey(requested);
+        const twinProblem = layerTwinProblem(requested, this.#audited.get(auditKey) ?? requested);
+        if (twinProblem)
+            throw new Error(`Layer ${JSON.stringify(requested)}: ${twinProblem}`);
         const color = options.color ?? existing?.color ?? 7;
         const colorProblem = layerColorProblem(color);
         if (colorProblem)
             throw new Error(`Layer ${JSON.stringify(requested)}: ${colorProblem}`);
         const layer = { name: existing?.name ?? requested, color };
         this.#layers.set(key, layer);
+        if (!this.#audited.has(auditKey))
+            this.#audited.set(auditKey, layer.name);
         if (draw) {
             const previous = this.#current;
             this.#current = layer.name;
@@ -70,6 +80,11 @@ export class DrawingBuilder {
         const [x, y] = pt(corner);
         const w = positive(width, "width");
         const h = positive(height, "height");
+        // A side can still vanish in the file: a corner and the one across from it may round together.
+        if (written(x + w) === written(x))
+            throw new Error(lostSide("width", "x", x));
+        if (written(y + h) === written(y))
+            throw new Error(lostSide("height", "y", y));
         return this.polyline([
             [x, y],
             [x + w, y],
@@ -89,12 +104,19 @@ export class DrawingBuilder {
      * Arc from `startAngle` counterclockwise to `endAngle`. Angles are stored
      * from 0 up to 360, so -90 becomes 270, because AutoCAD's AUDIT rejects
      * angles outside that range.
+     *
+     * Angles are written with 6 decimals. An arc within 0.000001 degrees of a
+     * full turn would be written with equal angles, which AutoCAD holds as an
+     * arc of no length, so it throws: draw a circle instead.
      */
     arc(center, radius, startAngle, endAngle) {
         const start = turn(num(startAngle, "startAngle"));
         const end = turn(num(endAngle, "endAngle"));
         if (start === end)
             throw new Error("An arc's start and end angles must differ");
+        const problem = arcProblem(start, end);
+        if (problem)
+            throw new Error(problem);
         return this.#add({
             kind: "arc",
             layer: this.#current,
@@ -114,7 +136,7 @@ export class DrawingBuilder {
             at: pt(at),
             value,
             height: positive(options.height ?? 0.125, "height"),
-            rotation: num(options.rotation ?? 0, "rotation"),
+            rotation: kept(options.rotation ?? 0, "rotation"),
         });
     }
     build() {
@@ -153,10 +175,21 @@ function positive(value, label) {
     if (typeof value !== "number" || !Number.isFinite(value)) {
         throw new Error(`${label} must be a finite number`);
     }
-    if (value <= 0)
-        throw new Error(`${label} must be greater than 0`);
+    const problem = sizeProblem(value);
+    if (problem)
+        throw new Error(`${label}: ${problem}`);
+    return value;
+}
+function lostSide(size, axis, at) {
+    return `${size}: This value is too small at ${axis} = ${at}. Both sides of the rectangle are written as ${axis} = ${fmt(at)}, because tsdraft writes 6 decimals`;
+}
+/** A number the drawing keeps and the writers print, which AutoCAD must be able to read. */
+function kept(value, label) {
+    const problem = magnitudeProblem(num(value, label));
+    if (problem)
+        throw new Error(`${label}: ${problem}`);
     return value;
 }
 function pt(point) {
-    return [num(point[0], "x"), num(point[1], "y")];
+    return [kept(point[0], "x"), kept(point[1], "y")];
 }

package/dist/dxf-r12.d.ts

@@ -6,5 +6,6 @@ import type { Drawing } from "./drawing.ts";
  * R12 has no header variable for drawing units, so coordinates are written as
  * plain numbers in the drawing's units and `drawing.units` is not written.
  * R12 predates Unicode DXF, so text outside ASCII is written as `\U+XXXX`.
+ * Layer `0` is written first, wherever it is in `drawing.layers`.
  */
 export declare function toDXFR12(drawing: Drawing): string;

package/dist/dxf-r12.js

@@ -1,4 +1,5 @@
-import { dxfText, fmt } from "./format.js";
+import { dxfText, fmt, writtenAngle } from "./format.js";
+import { layerZeroFirst } from "./layers.js";
 /**
  * Writes an ASCII DXF (AC1009, R12). R12 is the most widely readable DXF:
  * AutoCAD, BricsCAD, LibreCAD, QCAD and most converters open it.
@@ -6,6 +7,7 @@ import { dxfText, fmt } from "./format.js";
  * R12 has no header variable for drawing units, so coordinates are written as
  * plain numbers in the drawing's units and `drawing.units` is not written.
  * R12 predates Unicode DXF, so text outside ASCII is written as `\U+XXXX`.
+ * Layer `0` is written first, wherever it is in `drawing.layers`.
  */
 export function toDXFR12(drawing) {
     const out = [];
@@ -33,7 +35,7 @@ export function toDXFR12(drawing) {
     g(0, "TABLE");
     g(2, "LAYER");
     g(70, String(drawing.layers.length));
-    for (const layer of drawing.layers) {
+    for (const layer of layerZeroFirst(drawing.layers)) {
         g(0, "LAYER");
         g(2, layer.name);
         g(70, "0");
@@ -95,8 +97,8 @@ function writeEntity(e, g) {
             g(20, e.center[1]);
             g(30, 0);
             g(40, e.radius);
-            g(50, e.startAngle);
-            g(51, e.endAngle);
+            g(50, writtenAngle(e.startAngle));
+            g(51, writtenAngle(e.endAngle));
             return;
         case "text":
             g(0, "TEXT");

package/dist/dxf-r2018.js

@@ -1,5 +1,6 @@
 import { extents } from "./extents.js";
-import { dxfText, fmt } from "./format.js";
+import { dxfText, fmt, readable, writtenAngle } from "./format.js";
+import { layerZeroFirst } from "./layers.js";
 /** `$INSUNITS` codes from the DXF Reference. */
 const INSUNITS = { in: 1, ft: 2, mm: 4, cm: 5, m: 6 };
 /**
@@ -21,7 +22,14 @@ export function toDXFR2018(drawing) {
     const normalPlotStyle = handle();
     const modelSpace = handle();
     const paperSpace = handle();
-    const [minX, minY, maxX, maxY] = extents(drawing.entities);
+    // The extents are worked out here, so they are brought into the range AutoCAD reads.
+    const [left, bottom, right, top] = extents(drawing.entities);
+    const [minX, minY, maxX, maxY] = [
+        readable(left),
+        readable(bottom),
+        readable(right),
+        readable(top),
+    ];
     g(0, "SECTION");
     g(2, "CLASSES");
     g(0, "ENDSEC");
@@ -52,7 +60,9 @@ export function toDXFR2018(drawing) {
             g(40, 0);
         },
     })));
-    writeTable(g, handle, "LAYER", drawing.layers.map((layer) => ({
+    writeTable(g, handle, "LAYER", 
+    // AUDIT reports "Layer zero name found at incorrect index" unless layer 0 comes first.
+    layerZeroFirst(drawing.layers).map((layer) => ({
         type: "LAYER",
         subclass: "AcDbLayerTableRecord",
         name: layer.name,
@@ -222,7 +232,8 @@ function writeTable(g, handle, name, records) {
 /** The *Active viewport, zoomed to the drawing's extents so the file opens on the drawing. */
 function writeActiveViewport(g, minX, minY, maxX, maxY) {
     const aspect = 1.6;
-    const height = Math.max(maxY - minY, (maxX - minX) / aspect, 1) * 1.1;
+    // A drawing can span more than AutoCAD can read as one number, so the height is capped.
+    const height = readable(Math.max(maxY - minY, (maxX - minX) / aspect, 1) * 1.1);
     g(10, 0); // lower-left corner of the viewport on screen
     g(20, 0);
     g(11, 1); // upper-right corner
@@ -315,8 +326,8 @@ function writeEntity(g, e, handle, owner) {
             point(g, 10, ...e.center);
             g(40, e.radius);
             g(100, "AcDbArc");
-            g(50, e.startAngle);
-            g(51, e.endAngle);
+            g(50, writtenAngle(e.startAngle));
+            g(51, writtenAngle(e.endAngle));
             return;
         case "text":
             begin("TEXT", "AcDbText");

package/dist/format.d.ts

@@ -1,9 +1,38 @@
+/**
+ * A number as the writers print it: rounded to 6 decimals. Two values that are
+ * equal here are the same number in the file, whatever they were in the drawing.
+ */
+export declare function written(value: number): number;
+/**
+ * An arc angle in degrees as the DXF writers print it: rounded to 6 decimals,
+ * with 0 in place of an angle that rounds up to 360.
+ */
+export declare function writtenAngle(degrees: number): number;
+/**
+ * True for a number AutoCAD would misread from DXF, because it is 1e100 or
+ * more in size. `lint` refuses these wherever a drawing holds one.
+ */
+export declare function isTooLarge(value: number): boolean;
+/**
+ * Brings a number a writer works out for itself, such as an extent or the
+ * height of the view, into the range AutoCAD reads. `lint` cannot vouch for
+ * those: two coordinates under 1e100 can be more than 1e100 apart.
+ */
+export declare function readable(value: number): number;
 /** Formats a coordinate with at most 6 decimals, no float noise, and no "-0". */
 export declare function fmt(value: number): string;
 /**
- * Escapes a string value for DXF. A caret starts a control-character escape in
- * DXF, and AutoCAD discards the drawing when it meets a bare one, so a literal
- * caret is written as a caret and a space.
+ * Escapes a string value for DXF, so that AutoCAD holds the string as given.
+ *
+ * A caret starts a control-character escape in DXF, and AutoCAD discards the
+ * drawing when it meets a bare one, so a literal caret is written as a caret
+ * and a space.
+ *
+ * AutoCAD decodes `\U+XXXX` and `\M+NXXXX` in a string, and it does so twice.
+ * A backslash that would start one is written as `\U+005CU+005C`: the first
+ * pass leaves `\U+005C` and the second leaves the backslash, with nothing left
+ * to decode what follows it. This lasts until AutoCAD saves the drawing:
+ * AutoCAD writes the text unescaped, so it decodes it on a later open.
  *
  * With `ascii`, characters outside ASCII become `\U+XXXX`, which is how DXF
  * versions before 2007 carry them. Later versions are UTF-8 and need no escape.

package/dist/format.js

@@ -1,18 +1,72 @@
+/** The number of decimals the writers keep. */
+const DECIMALS = 6;
+/**
+ * A number as the writers print it: rounded to 6 decimals. Two values that are
+ * equal here are the same number in the file, whatever they were in the drawing.
+ */
+export function written(value) {
+    const rounded = Number(value.toFixed(DECIMALS));
+    return Object.is(rounded, -0) ? 0 : rounded;
+}
+/**
+ * An arc angle in degrees as the DXF writers print it: rounded to 6 decimals,
+ * with 0 in place of an angle that rounds up to 360.
+ */
+export function writtenAngle(degrees) {
+    const rounded = written(degrees);
+    return rounded >= 360 ? rounded - 360 : rounded;
+}
+/**
+ * The size from which a number prints with three exponent digits, as `1e+100`.
+ * AutoCAD reads only two from DXF: it takes `1e+100` for `1e+10` and
+ * `1e+308` for `1e+30`, with no AUDIT error. Writing the digits out does not
+ * help, because AutoCAD takes a number of 101 digits for 0.
+ */
+const TOO_LARGE = 1e100;
+/** The largest number under `TOO_LARGE`. */
+const LARGEST = 9.999999999999998e99;
+/**
+ * True for a number AutoCAD would misread from DXF, because it is 1e100 or
+ * more in size. `lint` refuses these wherever a drawing holds one.
+ */
+export function isTooLarge(value) {
+    return Math.abs(value) >= TOO_LARGE;
+}
+/**
+ * Brings a number a writer works out for itself, such as an extent or the
+ * height of the view, into the range AutoCAD reads. `lint` cannot vouch for
+ * those: two coordinates under 1e100 can be more than 1e100 apart.
+ */
+export function readable(value) {
+    return Math.max(-LARGEST, Math.min(LARGEST, value));
+}
 /** Formats a coordinate with at most 6 decimals, no float noise, and no "-0". */
 export function fmt(value) {
-    const rounded = Number(value.toFixed(6));
-    return Object.is(rounded, -0) ? "0" : String(rounded);
+    return String(written(value));
 }
 /**
- * Escapes a string value for DXF. A caret starts a control-character escape in
- * DXF, and AutoCAD discards the drawing when it meets a bare one, so a literal
- * caret is written as a caret and a space.
+ * A backslash that starts a `\U+XXXX` or `\M+NXXXX` sequence. AutoCAD decodes
+ * both forms in a DXF string, in either letter case.
+ */
+const ESCAPE_START = /\\(?=[Uu]\+[0-9A-Fa-f]{4}|[Mm]\+[1-5][0-9A-Fa-f]{4})/g;
+/**
+ * Escapes a string value for DXF, so that AutoCAD holds the string as given.
+ *
+ * A caret starts a control-character escape in DXF, and AutoCAD discards the
+ * drawing when it meets a bare one, so a literal caret is written as a caret
+ * and a space.
+ *
+ * AutoCAD decodes `\U+XXXX` and `\M+NXXXX` in a string, and it does so twice.
+ * A backslash that would start one is written as `\U+005CU+005C`: the first
+ * pass leaves `\U+005C` and the second leaves the backslash, with nothing left
+ * to decode what follows it. This lasts until AutoCAD saves the drawing:
+ * AutoCAD writes the text unescaped, so it decodes it on a later open.
  *
  * With `ascii`, characters outside ASCII become `\U+XXXX`, which is how DXF
  * versions before 2007 carry them. Later versions are UTF-8 and need no escape.
  */
 export function dxfText(value, ascii = false) {
-    const escaped = value.replaceAll("^", "^ ");
+    const escaped = value.replace(ESCAPE_START, "\\U+005CU+005C").replaceAll("^", "^ ");
     if (!ascii)
         return escaped;
     let out = "";