@formicoidea/labre-framework-uml 0.50.0 → 0.52.0

package/dist/import.js

@@ -1,4 +1,4 @@
-import { connectorEndLabelBox, ConnectorMode, TextAlign, UML_FRAME_BAND_HEIGHT, UML_LIFELINE_HEAD, } from '@formicoidea/labre-core/model';
+import { connectorEndLabelBox, ConnectorMode, TextAlign, UML_FRAME_BAND_HEIGHT, UML_LIFELINE_HEAD, } from '@formicoidea/labre-core/model/headless';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
 import { umlCompartmentBoxes, umlLabelRoleOf, } from './component.js';
 import { UML_BODY_FONT_SIZE, UML_DIAGRAM_BOX, UML_EDGE_WIDTH, UML_FRAGMENT_BOX, UML_INK, UML_NAME_FONT_SIZE, UML_NODE_BOX, UML_PARTITION_BOX, UML_REGION_BOX, UML_SUBJECT_BOX, } from './consts.js';
@@ -184,8 +184,10 @@ export function umlSequenceFragment(columns, y0, y1) {
         return { x: 0, y: y0, w: UML_FRAGMENT_BOX.w, h: Math.max(1, y1 - y0) };
     }
     const centres = columns.map(column => column.x + column.w / 2);
-    const left = Math.min(...centres) - UML_SD_FRAGMENT_PADDING;
-    const right = Math.max(...centres) + UML_SD_FRAGMENT_PADDING;
+    const left = centres.reduce((a, b) => Math.min(a, b), Infinity) -
+        UML_SD_FRAGMENT_PADDING;
+    const right = centres.reduce((a, b) => Math.max(a, b), -Infinity) +
+        UML_SD_FRAGMENT_PADDING;
     return { x: left, y: y0, w: right - left, h: Math.max(1, y1 - y0) };
 }
 /**
@@ -237,8 +239,12 @@ export function umlInventLayout(nodes, relations = []) {
         const inner = children.map(measure);
         const columns = Math.ceil(Math.sqrt(children.length));
         const rows = Math.ceil(children.length / columns);
-        const cellW = Math.max(...inner.map(box => box.w));
-        const cellH = Math.max(...inner.map(box => box.h));
+        const cellW = inner
+            .map(box => box.w)
+            .reduce((a, b) => Math.max(a, b), -Infinity);
+        const cellH = inner
+            .map(box => box.h)
+            .reduce((a, b) => Math.max(a, b), -Infinity);
         const size = {
             w: Math.max(node.size.w, UML_IMPORT_CONTAINER_INSET * 2 +
                 columns * cellW +
@@ -283,8 +289,12 @@ export function umlInventLayout(nodes, relations = []) {
         if (children.length === 0)
             return;
         const columns = Math.ceil(Math.sqrt(children.length));
-        const cellW = Math.max(...children.map(child => (measured.get(child.id) ?? child.size).w));
-        const cellH = Math.max(...children.map(child => (measured.get(child.id) ?? child.size).h));
+        const cellW = children
+            .map(child => (measured.get(child.id) ?? child.size).w)
+            .reduce((a, b) => Math.max(a, b), -Infinity);
+        const cellH = children
+            .map(child => (measured.get(child.id) ?? child.size).h)
+            .reduce((a, b) => Math.max(a, b), -Infinity);
         children.forEach((child, index) => {
             const column = index % columns;
             const row = Math.floor(index / columns);
@@ -899,10 +909,22 @@ export function umlElementsFromModel(models, options) {
         const drawn = drafts
             .map(draft => draft.bounds)
             .filter((box) => box !== undefined);
-        const left = drawn.length > 0 ? Math.min(...drawn.map(box => box.x)) : 0;
-        const top = drawn.length > 0 ? Math.min(...drawn.map(box => box.y)) : 0;
-        const right = drawn.length > 0 ? Math.max(...drawn.map(box => box.x + box.w)) : 0;
-        const bottom = drawn.length > 0 ? Math.max(...drawn.map(box => box.y + box.h)) : 0;
+        const left = drawn.length > 0
+            ? drawn.map(box => box.x).reduce((a, b) => Math.min(a, b), Infinity)
+            : 0;
+        const top = drawn.length > 0
+            ? drawn.map(box => box.y).reduce((a, b) => Math.min(a, b), Infinity)
+            : 0;
+        const right = drawn.length > 0
+            ? drawn
+                .map(box => box.x + box.w)
+                .reduce((a, b) => Math.max(a, b), -Infinity)
+            : 0;
+        const bottom = drawn.length > 0
+            ? drawn
+                .map(box => box.y + box.h)
+                .reduce((a, b) => Math.max(a, b), -Infinity)
+            : 0;
         const frame = {
             x: origin.x,
             y: frameTop,
@@ -1182,7 +1204,9 @@ function placeDrafts(drafts, model, layout) {
             .map(draft => draft.bounds)
             .filter((box) => box !== undefined);
         const below = placed.length > 0
-            ? Math.max(...placed.map(box => box.y + box.h)) + UML_IMPORT_GUTTER
+            ? placed
+                .map(box => box.y + box.h)
+                .reduce((a, b) => Math.max(a, b), -Infinity) + UML_IMPORT_GUTTER
             : 0;
         // Containment, so the invented layout draws the nesting the file stated:
         // a class in its package, a case in its subject, an action in its lane, a

package/dist/interchange-headless.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `@labre/affine-gfx-uml/interchange` — UML's whole interchange, with no editor
+ * behind it (ADR 0012, P3 as amended 2026-10-14).
+ *
+ * Every UML capability is pure on plain data — the exporters read structural
+ * records (`umlModelsFrom` picks by `type`, never by `instanceof`) — so this
+ * entry is the registry list itself, plus `decodeDrawio`, the container step a
+ * server runs before `uml:drawio:import` (capped, `DRAWIO_MAX_INFLATED_BYTES`).
+ *
+ * Held by `interchange-headless.unit.spec.ts` in `packages/affine/all`.
+ */
+export * from './drawio-decode.js';
+export * from './interchange.js';

package/dist/interchange-headless.js

@@ -0,0 +1,13 @@
+/**
+ * `@labre/affine-gfx-uml/interchange` — UML's whole interchange, with no editor
+ * behind it (ADR 0012, P3 as amended 2026-10-14).
+ *
+ * Every UML capability is pure on plain data — the exporters read structural
+ * records (`umlModelsFrom` picks by `type`, never by `instanceof`) — so this
+ * entry is the registry list itself, plus `decodeDrawio`, the container step a
+ * server runs before `uml:drawio:import` (capped, `DRAWIO_MAX_INFLATED_BYTES`).
+ *
+ * Held by `interchange-headless.unit.spec.ts` in `packages/affine/all`.
+ */
+export * from './drawio-decode.js';
+export * from './interchange.js';

package/dist/interchange.js

@@ -1,4 +1,4 @@
-import { interchangeCapabilityId } from '@formicoidea/labre-core/blocks/surface';
+import { interchangeCapabilityId } from '@formicoidea/labre-core/interchange';
 import { importDrawio, UML_DRAWIO_FORMAT_ID } from './drawio-import.js';
 import { exportUmlPlantuml, exportUmlXmi } from './export.js';
 import { umlSafeFilename } from './filename.js';

package/dist/keywords.js

@@ -297,7 +297,9 @@ export const UML_SLOTS_SEED_KEY = 'com.labre.uml.seed.slots';
  * tool that predates a unicode-safe pipeline writes, and a class pasted in from
  * one would otherwise export as a class named `<<interface>> Foo`.
  */
-const GUILLEMET_GROUP = /«([^»]*)»|<<([^>]*)>>/g;
+// Bounded, as `STEREOTYPE` in `plantuml-import.ts` is and for its reason:
+// `[^>]*` re-scanned the line from every `<<` that never closed.
+const GUILLEMET_GROUP = /«([^»]{0,256})»|<<([^>]{0,256})>>/g;
 /** `{abstract}`, with whatever spacing and case the author used (§9.2.4). */
 const ABSTRACT_MARKER = /\{\s*abstract\s*\}/i;
 /**

package/dist/model.d.ts

@@ -1,4 +1,4 @@
-import { type UmlDiagramKind, type UmlFragmentOperand, type UmlFragmentOperator, type UmlNodeKind } from '@formicoidea/labre-core/model';
+import type { UmlDiagramKind, UmlFragmentOperand, UmlFragmentOperator, UmlNodeKind } from '@formicoidea/labre-core/model';
 import { type UmlBox, type UmlComponent, type UmlComponentElement, type UmlComponentGroup } from './component.js';
 import { type UmlAssociationEnd, type UmlOperation, type UmlProperty } from './grammar.js';
 /**
@@ -595,6 +595,13 @@ export interface UmlModel {
      */
     warnings: string[];
 }
+/**
+ * The relationship a connector ROLE states — `uml:generalization` → `'generalization'`
+ * — or `undefined` for a role that states none. The one reading of
+ * {@link RELATION_ROLE} backwards, exported for the draw.io reader, which meets
+ * the same roles as `labre-role` attributes on a drawing the canvas wrote.
+ */
+export declare function umlRelationKindOfRole(role: string | undefined): UmlRelationKind | undefined;
 /**
  * An element's box, from whichever of the three spellings it carries.
  *

package/dist/model.js

@@ -1,4 +1,4 @@
-import { UML_DIAGRAM_KIND_TAG, UML_FRAGMENT_BAND, UML_FRAME_BAND_HEIGHT, UML_LIFELINE_HEAD, } from '@formicoidea/labre-core/model';
+import { UML_DIAGRAM_KIND_TAG, UML_FRAGMENT_BAND, UML_FRAME_BAND_HEIGHT, UML_LIFELINE_HEAD, } from '@formicoidea/labre-core/model/headless';
 import { umlComponentSiblings, umlGroupOf, umlTierText, } from './component.js';
 import { parseActivityEdge, parseCompartment, parseEndLabel, parseLifelineIdent, parseOperation, parseProperty, parseStateBehavior, parseTransition, } from './grammar.js';
 import { stereotypesOf } from './keywords.js';
@@ -60,6 +60,15 @@ const RELATION_OF_ROLE = new Map(Object.entries(RELATION_ROLE).map(([kind, role]
     role,
     kind,
 ]));
+/**
+ * The relationship a connector ROLE states — `uml:generalization` → `'generalization'`
+ * — or `undefined` for a role that states none. The one reading of
+ * {@link RELATION_ROLE} backwards, exported for the draw.io reader, which meets
+ * the same roles as `labre-role` attributes on a drawing the canvas wrote.
+ */
+export function umlRelationKindOfRole(role) {
+    return role === undefined ? undefined : RELATION_OF_ROLE.get(role);
+}
 /* ── Geometry ─────────────────────────────────────────────────────────── */
 /**
  * An element's box, from whichever of the three spellings it carries.

package/dist/plantuml-import.d.ts

@@ -94,6 +94,16 @@ export interface UmlPlantumlImport {
  * They are contributed to the manifest by `./translations.ts`, with the
  * framework, because they ship in the UML bundle rather than in core.
  */
+/**
+ * The most PlantUML source the reader takes: 1 MiB, the size of a diagram
+ * nobody types, and the bound on what the line regexes below can be handed
+ * (the server's budget: 256 MiB, two seconds).
+ */
+export declare const PLANTUML_MAX_CHARACTERS: number;
+/** The reader's refusal, static so a server can hand the key on (ADR 0023). */
+export declare const UML_PLANTUML_ERRORS: {
+    readonly tooLarge: readonly ["com.labre.uml.import.plantuml.too-large", "This PlantUML file is longer than an import accepts, so it was not read."];
+};
 export declare const UML_PLANTUML_REMARKS: {
     readonly relationEnd: readonly ["com.labre.uml.import.plantuml.relation-end", "The {{side}} end of the {{kind}} between \"{{left}}\" and \"{{right}}\" is written \"{{raw}}\". It is drawn on the board, but UML gives that relationship's ends no multiplicity, so no export writes it."];
     readonly duplicateDeclaration: readonly ["com.labre.uml.import.plantuml.duplicate-declaration", "This document declares \"{{name}}\" twice. The second declaration was read as a separate artefact under an id of Labre's own."];

package/dist/plantuml-import.js

@@ -1,4 +1,5 @@
-import { UML_DIAGRAM_KIND_TAG, } from '@formicoidea/labre-core/model';
+import { InterchangeImportError } from '@formicoidea/labre-core/interchange';
+import { UML_DIAGRAM_KIND_TAG } from '@formicoidea/labre-core/model/headless';
 import { UML_FRAGMENT_BOX, UML_NODE_BOX, UML_REGION_BOX, UML_SUBJECT_BOX, } from './consts.js';
 import { parseEndLabel, parseLifelineIdent, parseOperation, parseProperty, parseTransition, } from './grammar.js';
 import { UML_SD_COLUMN_GAP, UML_SD_EVENT_STEP, UML_SD_FRAGMENT_PADDING, umlInventLayout, umlSequenceColumn, umlSequenceDestruction, umlSequenceExecution, umlSequenceFragment, umlSequenceSlot, } from './import.js';
@@ -33,6 +34,19 @@ import { ADORNED_RELATION_KINDS } from './model.js';
  * They are contributed to the manifest by `./translations.ts`, with the
  * framework, because they ship in the UML bundle rather than in core.
  */
+/**
+ * The most PlantUML source the reader takes: 1 MiB, the size of a diagram
+ * nobody types, and the bound on what the line regexes below can be handed
+ * (the server's budget: 256 MiB, two seconds).
+ */
+export const PLANTUML_MAX_CHARACTERS = 1024 * 1024;
+/** The reader's refusal, static so a server can hand the key on (ADR 0023). */
+export const UML_PLANTUML_ERRORS = {
+    tooLarge: [
+        'com.labre.uml.import.plantuml.too-large',
+        'This PlantUML file is longer than an import accepts, so it was not read.',
+    ],
+};
 export const UML_PLANTUML_REMARKS = {
     relationEnd: [
         'com.labre.uml.import.plantuml.relation-end',
@@ -82,7 +96,7 @@ const KIND_OF_TAG = new Map(Object.entries(UML_DIAGRAM_KIND_TAG).map(([kind, tag
  * boundary box — because that is the only thing this pack draws round a group of
  * use cases, and it is what our own writer emits for one.
  */
-const DECLARATION_KIND = {
+const DECLARATION_KIND = Object.assign(Object.create(null), {
     class: 'class',
     entity: 'class',
     interface: 'interface',
@@ -100,7 +114,7 @@ const DECLARATION_KIND = {
     artifact: 'artifact',
     node: 'node',
     state: 'state',
-};
+});
 /** The declaration words, as the alternation the line matcher is built on. */
 const DECLARATION_WORDS = [
     'abstract class',
@@ -117,7 +131,9 @@ const DECLARATION_WORDS = [
  * (a terminate was borrowing the stop). Reading them the other way would turn a
  * diagram somebody drew into a different one on the way home.
  */
-const STATE_KIND_OF_STEREOTYPE = {
+// No prototype, like every table here read by a word the FILE wrote:
+// `<<constructor>>` must read as a stereotype, not as `Object`.
+const STATE_KIND_OF_STEREOTYPE = Object.assign(Object.create(null), {
     start: 'initial',
     end: 'final-state',
     choice: 'choice',
@@ -128,7 +144,7 @@ const STATE_KIND_OF_STEREOTYPE = {
     entrypoint: 'entry-point',
     exitpoint: 'exit-point',
     terminate: 'terminate',
-};
+});
 /** The vertices §14.2.4.6 files under `Pseudostate`, as a set. */
 const PSEUDOSTATE_KINDS = new Set([
     'initial',
@@ -184,18 +200,25 @@ const OPERATORS = [
  * role, and reading it as prose would import an include as an untyped dependency
  * carrying a stereotype.
  */
-const KEYWORD_ROLE = {
+const KEYWORD_ROLE = Object.assign(Object.create(null), {
     include: 'include',
     extend: 'extend',
     deploy: 'deploy',
     manifest: 'manifest',
     use: 'dependency',
-};
+});
 /** PlantUML's contextual beginning-and-end marker (`plantuml.ts`). */
 const TERMINAL = '[*]';
 /* ── Reading a line ───────────────────────────────────────────────────── */
-/** A `<<stereo>>` / `«stereo»` group, wherever it was written. */
-const STEREOTYPE = /<<([^>]*)>>|«([^»]*)»/g;
+/**
+ * A `<<stereo>>` / `«stereo»` group, wherever it was written.
+ *
+ * Bounded like draw.io's `ASCII_GUILLEMETS`: an unbounded `[^>]*` re-scanned
+ * the rest of the line from every `<<` that never closed, 1.8 s for a 40 KiB
+ * `class A <<<<…` and four times that per doubling (counter-review of
+ * 49aa247ce). No stereotype is 256 characters long.
+ */
+const STEREOTYPE = /<<([^>]{0,256})>>|«([^»]{0,256})»/g;
 /** Direction hints inside an arrow — `-down->`, `-up->`: layout, not model. */
 const DIRECTION_HINT = /-(?:left|right|up|down|le|ri|do)-/gi;
 /** A colour or a style tail — `#red`, `#line:blue;line.dashed`. */
@@ -1020,6 +1043,11 @@ function layOut(model, contains) {
  * the same source always produces the same models, down to the coordinates.
  */
 export function importPlantuml(source) {
+    if (source.length > PLANTUML_MAX_CHARACTERS) {
+        throw new InterchangeImportError(UML_PLANTUML_ERRORS.tooLarge[1], {
+            messageKey: UML_PLANTUML_ERRORS.tooLarge[0],
+        });
+    }
     const notes = [];
     const note = (entry) => notes.push(entry);
     const lines = source.replaceAll('\r\n', '\n').split('\n');
@@ -1125,7 +1153,7 @@ function sequenceArrow(token) {
     };
 }
 /** §17.6.4's operators, read back off the block keyword that opened them. */
-const FRAGMENT_OPERATOR_OF_WORD = {
+const FRAGMENT_OPERATOR_OF_WORD = Object.assign(Object.create(null), {
     alt: 'alt',
     opt: 'opt',
     loop: 'loop',
@@ -1138,7 +1166,7 @@ const FRAGMENT_OPERATOR_OF_WORD = {
     assert: 'assert',
     ignore: 'ignore',
     consider: 'consider',
-};
+});
 /**
  * The declarations that can only be a CLASS diagram — §9's classifiers and
  * §12's package.

package/dist/presets.d.ts

@@ -1,4 +1,5 @@
-import { TextAlign, TextDecoration, type UmlNodeKind } from '@formicoidea/labre-core/model';
+import { TextAlign, TextDecoration } from '@formicoidea/labre-core/model/headless';
+import type { UmlNodeKind } from '@formicoidea/labre-core/model';
 import type { UmlBox } from './component.js';
 /**
  * What a UML shape IS, as props — the ONE description the creation site, the

package/dist/presets.js

@@ -1,4 +1,4 @@
-import { FontFamily, FontStyle, FontWeight, ShapeStyle, StrokeStyle, TextAlign, TextDecoration, } from '@formicoidea/labre-core/model';
+import { FontFamily, FontStyle, FontWeight, ShapeStyle, StrokeStyle, TextAlign, TextDecoration, } from '@formicoidea/labre-core/model/headless';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
 import { UML_CARD, UML_INK, UML_NAME_FONT_SIZE, UML_NODE_BOX, UML_NODE_RADIUS, UML_NODE_STROKE_WIDTH, } from './consts.js';
 import { UML_ROLE_OF_KIND } from './roles.js';

package/dist/translations.js

@@ -1,18 +1,19 @@
 import { collectTranslationKeys, commandCategoryTranslationEntries, commandTranslationEntries, mergeTranslationEntries, } from '@formicoidea/labre-core/std';
 import { UML_DIAGRAM_FRAME, UML_SUBJECT_FRAME } from './background.js';
 import { umlCommands } from './commands.js';
+import { UML_DRAWIO_DECODE_ERRORS } from './drawio-decode.js';
 import { UML_DRAWIO_REMARKS } from './drawio-import.js';
 import { UML_LAYOUT_REMARKS } from './import.js';
 import { UML_ATTRIBUTES_SEED, UML_ATTRIBUTES_SEED_KEY, UML_NAME_SEED, UML_OPERATIONS_SEED, UML_OPERATIONS_SEED_KEY, UML_SLOTS_SEED, UML_SLOTS_SEED_KEY, umlSeedKey, } from './keywords.js';
 import { UML_DIAGRAM_KIND_MENU } from './kinds.js';
 import { UML_LEGEND_SECTION_WORDINGS } from './legend.js';
 import { UML_FRAGMENT_OPERATOR_MENU } from './operators.js';
-import { UML_PLANTUML_REMARKS } from './plantuml-import.js';
+import { UML_PLANTUML_ERRORS, UML_PLANTUML_REMARKS, } from './plantuml-import.js';
 import { UML_PROFILES } from './profiles.js';
 import { UML_READINGS } from './reading.js';
 import { UML_ROLES } from './roles.js';
 import { UML_RULES } from './rules.js';
-import { UML_XMI_REMARKS } from './xmi-import.js';
+import { UML_XMI_ERRORS, UML_XMI_REMARKS } from './xmi-import.js';
 /**
  * The words a placed artefact is SEEDED with — its name compartment, and the
  * three compartment lines a fresh classifier carries.
@@ -57,6 +58,9 @@ const chromeEntries = () => [
     ...Object.values(UML_PLANTUML_REMARKS),
     ...Object.values(UML_XMI_REMARKS),
     ...Object.values(UML_DRAWIO_REMARKS),
+    ...Object.values(UML_DRAWIO_DECODE_ERRORS),
+    ...Object.values(UML_PLANTUML_ERRORS),
+    ...Object.values(UML_XMI_ERRORS),
     ...Object.values(UML_LAYOUT_REMARKS),
 ].map(([key, fallback]) => ({ key, fallback, source: 'chrome' }));
 /**

package/dist/xmi-import.d.ts

@@ -131,6 +131,18 @@ export declare const UML_XMI_QUARANTINE_REASON: {
  * cannot become a `[key, english]` pair without breaking that contract. BPMN
  * carries the identical constraint on its own quarantine reasons.
  */
+/**
+ * The deepest an XMI file may nest: 1 000 levels. The reader walks packages,
+ * consumed subtrees and the quarantine sweep by recursion, and 5 000 nested
+ * packages overflowed the stack with a bare `RangeError` (counter-review of
+ * 49aa247ce). A real model nests a few dozen levels; one cap at the door bounds
+ * every recursion below it.
+ */
+export declare const XMI_MAX_DEPTH = 1000;
+/** The reader's refusal, static so a server can hand the key on (ADR 0023). */
+export declare const UML_XMI_ERRORS: {
+    readonly tooDeep: readonly ["com.labre.uml.import.xmi.too-deep", "This XMI file nests its elements deeper than an import accepts, so it was not read."];
+};
 export declare const UML_XMI_REMARKS: {
     readonly mintedId: readonly ["com.labre.uml.import.xmi.minted-id", "<{{tag}}> carries no xmi:id, so one was minted for it. Nothing in the file can refer to it, and nothing does."];
     readonly unlistedOperator: readonly ["com.labre.uml.import.xmi.unlisted-operator", "This combined fragment's operator is \"{{operator}}\", which UML 2.5.1 §17.6.4 does not list. It is drawn as an \"alt\" and the file's own word is kept beside it."];

package/dist/xmi-import.js

@@ -1,3 +1,4 @@
+import { InterchangeImportError } from '@formicoidea/labre-core/interchange';
 import { UML_SD_EVENT_STEP, umlSequenceColumn, umlSequenceDestruction, umlSequenceExecution, umlSequenceFragment, umlSequenceSlot, } from './import.js';
 import { formatEndLabel, } from './grammar.js';
 import { readXml, xmlAttr, xmlChild, xmlChildren, xmlDescendants, xmlFragmentOf, } from './xml-reader.js';
@@ -14,7 +15,8 @@ import { readXml, xmlAttr, xmlChild, xmlChildren, xmlDescendants, xmlFragmentOf,
  */
 const META_PREFIXES = new Set(['uml', 'UML', 'Uml']);
 /** The classifier metaclasses, and the {@link UmlClassifier.kind} each is. */
-const CLASSIFIER_KIND = {
+// Tables read by a name the FILE wrote have no prototype (`<constructor>`).
+const CLASSIFIER_KIND = Object.assign(Object.create(null), {
     Class: 'class',
     Interface: 'interface',
     Enumeration: 'enumeration',
@@ -25,20 +27,20 @@ const CLASSIFIER_KIND = {
     // file said.
     DataType: 'class',
     PrimitiveType: 'class',
-};
+});
 /** The metaclasses {@link CLASSIFIER_KIND} maps that need their keyword said. */
-const CLASSIFIER_KEYWORD = {
+const CLASSIFIER_KEYWORD = Object.assign(Object.create(null), {
     DataType: 'datatype',
     PrimitiveType: 'primitive',
-};
+});
 /** The three cubes of §19.4.2, and the one `kind` they differ by. */
-const DEPLOYMENT_KIND = {
+const DEPLOYMENT_KIND = Object.assign(Object.create(null), {
     Node: 'node',
     Device: 'device',
     ExecutionEnvironment: 'execution-environment',
-};
+});
 /** The inverse of `xmi.ts`'s `ACTIVITY_NODE_TYPE`. */
-const ACTIVITY_NODE_KIND = {
+const ACTIVITY_NODE_KIND = Object.assign(Object.create(null), {
     OpaqueAction: 'action',
     Action: 'action',
     CallBehaviorAction: 'action',
@@ -58,9 +60,9 @@ const ACTIVITY_NODE_KIND = {
     // whose trigger names a TimeEvent, so the two are told apart by the EVENT and
     // not by the metaclass. See {@link readActivity}.
     AcceptEventAction: 'accept-event',
-};
+});
 /** The inverse of `xmi.ts`'s `PSEUDOSTATE_KIND` (§14.5.7's enumeration). */
-const PSEUDOSTATE_OF_KIND = {
+const PSEUDOSTATE_OF_KIND = Object.assign(Object.create(null), {
     initial: 'initial',
     choice: 'choice',
     junction: 'junction',
@@ -71,16 +73,16 @@ const PSEUDOSTATE_OF_KIND = {
     terminate: 'terminate',
     fork: 'fork',
     join: 'fork',
-};
+});
 /** The dependency metaclasses, and the relation each states. */
-const DEPENDENCY_KIND = {
+const DEPENDENCY_KIND = Object.assign(Object.create(null), {
     Dependency: 'dependency',
     Usage: 'dependency',
     Abstraction: 'dependency',
     Realization: 'realization',
     Deployment: 'deploy',
     Manifestation: 'manifest',
-};
+});
 /** What Labre stamps on the XMI extensions it writes — `xmi.ts`'s `EXTENDER`. */
 const LABRE_EXTENDER = 'labre';
 /** The four VisibilityKinds, as §7.4 spells them in a file. */
@@ -109,6 +111,33 @@ export const UML_XMI_QUARANTINE_REASON = {
  * cannot become a `[key, english]` pair without breaking that contract. BPMN
  * carries the identical constraint on its own quarantine reasons.
  */
+/**
+ * The deepest an XMI file may nest: 1 000 levels. The reader walks packages,
+ * consumed subtrees and the quarantine sweep by recursion, and 5 000 nested
+ * packages overflowed the stack with a bare `RangeError` (counter-review of
+ * 49aa247ce). A real model nests a few dozen levels; one cap at the door bounds
+ * every recursion below it.
+ */
+export const XMI_MAX_DEPTH = 1_000;
+/** The reader's refusal, static so a server can hand the key on (ADR 0023). */
+export const UML_XMI_ERRORS = {
+    tooDeep: [
+        'com.labre.uml.import.xmi.too-deep',
+        'This XMI file nests its elements deeper than an import accepts, so it was not read.',
+    ],
+};
+/** The depth of the deepest element, walked with a stack. */
+function depthOf(roots) {
+    let deepest = 0;
+    const stack = roots.map(node => ({ node, depth: 1 }));
+    while (stack.length > 0) {
+        const { node, depth } = stack.pop();
+        deepest = Math.max(deepest, depth);
+        for (const child of node.children)
+            stack.push({ node: child, depth: depth + 1 });
+    }
+    return deepest;
+}
 export const UML_XMI_REMARKS = {
     mintedId: [
         'com.labre.uml.import.xmi.minted-id',
@@ -233,16 +262,17 @@ function foreignOf(ctx, scope) {
 /** One attribute, kept under the scope of the element that carried it. */
 function carryAttr(ctx, owner, scope, name, value) {
     const payload = foreignOf(ctx, owner);
-    payload.attrs = {
-        ...payload.attrs,
-        [scope]: { ...payload.attrs?.[scope], [name]: value },
-    };
+    // In place, in bags with no prototype: a copy per attribute was quadratic,
+    // and the keys are the file's (BPMN's keep-helpers, same review).
+    const attrs = (payload.attrs ??= Object.create(null));
+    (attrs[scope] ??= Object.create(null))[name] =
+        value;
     ctx.counts.carried += 1;
 }
 /** One fragment, kept and declared un-re-emittable (D5). */
 function quarantine(ctx, owner, fragment, reason, entry) {
     const payload = foreignOf(ctx, owner);
-    payload.quarantined = [...(payload.quarantined ?? []), { fragment, reason }];
+    (payload.quarantined ??= []).push({ fragment, reason });
     ctx.counts.quarantined += 1;
     note(ctx, { kind: 'quarantined', ...entry, message: reason });
 }
@@ -293,7 +323,9 @@ function map(ctx, node) {
  * model everywhere in this format, and anything else on an element Labre draws
  * is something Labre does not model and must not lose.
  */
-const READ_ATTRS = {
+// No prototype: read by a local name the file chose (`<constructor>`), the
+// BPMN reader's TypeError (security review, 2026-10-14).
+const READ_ATTRS = Object.assign(Object.create(null), {
     packagedElement: [
         'xmi:type',
         'type',
@@ -339,7 +371,7 @@ const READ_ATTRS = {
         'isQuery',
     ],
     '': ['xmi:type', 'type', 'xmi:id', 'id', 'name'],
-};
+});
 /** Everything on this element the reader did not read, kept verbatim. */
 function carryUnknownAttrs(ctx, node, owner, scope = owner, understood = READ_ATTRS[node.local] ?? READ_ATTRS['']) {
     for (const [name, value] of Object.entries(node.attrs)) {
@@ -1219,14 +1251,14 @@ function readStateMachine(ctx, draft, node, id) {
 }
 /* ── Interactions (§17) ───────────────────────────────────────────────── */
 /** §17.4.3's `messageSort`, read back to the arrow §17.4.4 draws for it. */
-const MESSAGE_KIND_OF_SORT = {
+const MESSAGE_KIND_OF_SORT = Object.assign(Object.create(null), {
     synchCall: 'message-sync',
     asynchCall: 'message-async',
     asynchSignal: 'message-async',
     reply: 'message-reply',
     createMessage: 'message-create',
     deleteMessage: 'message-delete',
-};
+});
 /** The metaclasses §17.2.4 draws as the bar on a spine, whatever the tool. */
 const EXECUTION_TYPES = new Set([
     'BehaviorExecutionSpecification',
@@ -1999,6 +2031,11 @@ function rootOf(document) {
  */
 export function importXmi(source, context = {}) {
     const document = readXml(source);
+    if (depthOf(document.roots) > XMI_MAX_DEPTH) {
+        throw new InterchangeImportError(UML_XMI_ERRORS.tooDeep[1], {
+            messageKey: UML_XMI_ERRORS.tooDeep[0],
+        });
+    }
     // The three bags keyed by an id the FILE chose have no prototype: `__proto__`
     // and `constructor` are ids a document is free to use, and on a plain object
     // the first writes through to `Object.prototype` and the second reads a
@@ -2246,7 +2283,9 @@ export function umlElementsWithForeign(elements, foreign, formatId) {
     // Flattened onto the frame's own payload rather than nested under a second
     // key, because `ForeignInterchange` is one record per format and the SCOPES
     // inside it are what keep two source elements apart.
-    const attrs = residue.reduce((all, [, payload]) => ({ ...all, ...payload.attrs }), { ...own.attrs });
+    const attrs = residue.reduce((all, [, payload]) => Object.assign(all, payload.attrs), 
+    // No prototype: a scope is an id the file chose, `__proto__` included.
+    Object.assign(Object.create(null), own.attrs));
     const quarantined = [
         ...(own.quarantined ?? []),
         ...residue.flatMap(([, payload]) => payload.quarantined ?? []),