@mlightcad/data-model 1.10.4 → 1.10.6

package/lib/misc/AcDbMemoryEstimator.js

@@ -0,0 +1,753 @@
+/**
+ * @fileoverview Heuristic in-memory size estimator for {@link AcDbDatabase}.
+ *
+ * Walks the ownership graph with a {@link WeakSet} to avoid cycles and estimates
+ * bytes using V8-inspired constants. Results are reproducible and useful for
+ * comparing drawings; they are not exact Chrome heap retained sizes.
+ * Cross-check with `performance.memory` / DevTools heap snapshots when needed.
+ *
+ * @module AcDbMemoryEstimator
+ */
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { AcDbEntity } from '../entity/AcDbEntity';
+/** Estimated per-object header size in bytes (V8-inspired heuristic). */
+var OBJECT_OVERHEAD = 48;
+/** Estimated pointer / slot size in bytes. */
+var POINTER_SIZE = 8;
+/** Estimated array object header size in bytes. */
+var ARRAY_OVERHEAD = 48;
+/** Estimated `Map` object header size in bytes. */
+var MAP_OVERHEAD = 80;
+/** Estimated cost of one `Map` entry (excluding key/value payloads). */
+var MAP_ENTRY_OVERHEAD = 32;
+/** Estimated `Set` object header size in bytes. */
+var SET_OVERHEAD = 80;
+/** Estimated cost of one `Set` entry (excluding value payload). */
+var SET_ENTRY_OVERHEAD = 24;
+/** Estimated string object header size in bytes (UTF-16 payload billed separately). */
+var STRING_OVERHEAD = 40;
+/** Estimated size of a JavaScript `number`. */
+var NUMBER_SIZE = 8;
+/** Estimated size of a JavaScript `boolean`. */
+var BOOLEAN_SIZE = 4;
+/** Estimated TypedArray / ArrayBuffer object header size in bytes. */
+var TYPED_ARRAY_OVERHEAD = 64;
+/** Estimated `Blob` object header size in bytes (`size` billed separately). */
+var BLOB_OVERHEAD = 64;
+/**
+ * {@link AcDbDatabase} own-property names treated as system variables / header
+ * state when classifying memory into the `sysvars` category.
+ */
+var SYSVAR_KEYS = new Set([
+    '_version',
+    '_angbase',
+    '_angdir',
+    '_aunits',
+    '_auprec',
+    '_lunits',
+    '_luprec',
+    '_celtscale',
+    '_cecolor',
+    '_celtype',
+    '_celweight',
+    '_cetransparency',
+    '_clayer',
+    '_cmlstyle',
+    '_cmlscale',
+    '_cmleaderstyle',
+    '_hpbackgroundcolor',
+    '_hpcolor',
+    '_hplayer',
+    '_hptransparency',
+    '_textstyle',
+    '_extents',
+    '_insunits',
+    '_unitmode',
+    '_measurement',
+    '_ltscale',
+    '_lwdisplay',
+    '_pdmode',
+    '_pdsize',
+    '_osmode',
+    '_orthomode',
+    '_maxHandle',
+    '_drawNoPlotLayers',
+    '_dwgname',
+    '_currentSpace',
+    '_formatter',
+    '_eventBatchDepth',
+    '_pendingEntityAppended',
+    '_pendingEntityErased',
+    '_pendingDictObjectSet',
+    '_pendingDictObjectErased',
+    '_lastOpenError'
+]);
+/**
+ * Property names that are never walked (prototype / call-stack noise).
+ */
+var SKIP_ALWAYS = new Set([
+    'constructor',
+    'prototype',
+    '__proto__',
+    'caller',
+    'callee',
+    'arguments'
+]);
+/**
+ * Returns the bucket for `key`, creating an empty one when missing.
+ *
+ * @param map - Category or entity-type bucket map.
+ * @param key - Bucket key to look up or create.
+ * @returns The existing or newly created bucket.
+ * @internal
+ */
+function ensureBucket(map, key) {
+    var bucket = map.get(key);
+    if (!bucket) {
+        bucket = { bytes: 0, count: 0 };
+        map.set(key, bucket);
+    }
+    return bucket;
+}
+/**
+ * Adds estimated bytes (and optional object count) to a category bucket.
+ *
+ * No-op when both `bytes` and `objectDelta` are zero.
+ *
+ * @param state - Shared walk state.
+ * @param category - Category name to update.
+ * @param bytes - Bytes to add to the category.
+ * @param objectDelta - Object count delta to add (default `0`).
+ * @internal
+ */
+function addBytes(state, category, bytes, objectDelta) {
+    if (objectDelta === void 0) { objectDelta = 0; }
+    if (bytes <= 0 && objectDelta === 0)
+        return;
+    var bucket = ensureBucket(state.byCategory, category);
+    bucket.bytes += bytes;
+    bucket.count += objectDelta;
+}
+/**
+ * Returns whether `value` is a plain object (`Object` prototype or `null`
+ * prototype), as opposed to a class instance.
+ *
+ * @param value - Object to test.
+ * @returns `true` when `value` is a plain object.
+ * @internal
+ */
+function isPlainObject(value) {
+    var proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Type guard for TypedArray / DataView values (`ArrayBuffer.isView`).
+ *
+ * @param value - Value to test.
+ * @returns `true` when `value` is an {@link ArrayBufferView}.
+ * @internal
+ */
+function isTypedArray(value) {
+    return ArrayBuffer.isView(value);
+}
+/**
+ * Heuristic detection of {@link AcCmEventManager}-like objects so their
+ * listener lists can be skipped when event managers are excluded.
+ *
+ * @param value - Object to test.
+ * @returns `true` when `value` looks like an event manager.
+ * @internal
+ */
+function isAcCmEventManager(value) {
+    return (typeof value.addEventListener ===
+        'function' &&
+        typeof value.dispatch === 'function' &&
+        'listeners' in value);
+}
+/**
+ * Returns whether a property should be skipped based on walk options and
+ * always-skipped names.
+ *
+ * @param state - Shared walk state (options).
+ * @param key - Property name being considered.
+ * @param category - Current ownership category of the parent object.
+ * @returns `true` when the property must not be walked.
+ * @internal
+ */
+function shouldSkipProperty(state, key, category) {
+    if (SKIP_ALWAYS.has(key))
+        return true;
+    if (!state.includeEventManagers &&
+        (key === 'events' || category === 'events')) {
+        return key === 'events';
+    }
+    if (!state.includeTransactionManager &&
+        (key === 'transactionManager' || category === 'transaction')) {
+        return key === 'transactionManager';
+    }
+    return false;
+}
+/**
+ * Resolves the ownership category for a child value based on the parent
+ * category, property name, and runtime type.
+ *
+ * @param parentCategory - Category of the owning object.
+ * @param key - Child property name (or array index as string).
+ * @param value - Child value (used for entity detection).
+ * @returns Category to use when measuring the child.
+ * @internal
+ */
+function resolveChildCategory(parentCategory, key, value) {
+    if (key === '_xDataMap' || parentCategory === 'xdata') {
+        return 'xdata';
+    }
+    if (key === '_tables' || parentCategory === 'tables') {
+        if (value instanceof AcDbEntity)
+            return 'entities';
+        return 'tables';
+    }
+    if (key === '_entities' || parentCategory === 'entities') {
+        return 'entities';
+    }
+    if (key === '_objects' || parentCategory === 'objects') {
+        return 'objects';
+    }
+    if (key === '_handleRegistry' || parentCategory === 'handleRegistry') {
+        return 'handleRegistry';
+    }
+    if (key === 'transactionManager' || parentCategory === 'transaction') {
+        return 'transaction';
+    }
+    if (key === 'events' || parentCategory === 'events') {
+        return 'events';
+    }
+    if (parentCategory === 'sysvars' || SYSVAR_KEYS.has(key)) {
+        return 'sysvars';
+    }
+    if (value instanceof AcDbEntity) {
+        return 'entities';
+    }
+    return parentCategory === 'other' ? 'other' : parentCategory;
+}
+/**
+ * Collects instance data property names from `obj` and its class prototype
+ * chain (TypeScript `private` fields are still present as `_foo` on the
+ * instance / class field storage).
+ *
+ * Skips methods, accessors without a data value, and built-in prototypes
+ * such as `Array.prototype`.
+ *
+ * @param obj - Class instance or plain object to inspect.
+ * @returns Deduplicated list of instance property names.
+ * @internal
+ */
+function collectInstanceKeys(obj) {
+    var e_1, _a;
+    var keys = new Set();
+    var current = obj;
+    while (current && current !== Object.prototype) {
+        try {
+            for (var _b = (e_1 = void 0, __values(Object.getOwnPropertyNames(current))), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                if (SKIP_ALWAYS.has(key))
+                    continue;
+                // Skip prototype methods; we only want instance data fields.
+                var desc = Object.getOwnPropertyDescriptor(current, key);
+                if (desc && typeof desc.value === 'function')
+                    continue;
+                if (desc && (desc.get || desc.set) && desc.value === undefined)
+                    continue;
+                keys.add(key);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        current = Object.getPrototypeOf(current);
+        // Stop before walking built-in prototypes for class instances that store
+        // data only on the instance / custom prototypes above Object.
+        if (current === Object.prototype || current === null)
+            break;
+        // For arrays/maps, own keys on the instance are enough; avoid Array.prototype.
+        if (current === Array.prototype ||
+            current === Map.prototype ||
+            current === Set.prototype) {
+            break;
+        }
+    }
+    return __spreadArray([], __read(keys), false);
+}
+/**
+ * Estimates the size of a primitive value (number, boolean, string, bigint,
+ * or symbol). Returns `0` for `null`, `undefined`, and non-primitives.
+ *
+ * @param value - Value to measure.
+ * @returns Estimated size in bytes.
+ * @internal
+ */
+function measurePrimitive(value) {
+    var _a;
+    if (value === null || value === undefined)
+        return 0;
+    switch (typeof value) {
+        case 'number':
+            return NUMBER_SIZE;
+        case 'boolean':
+            return BOOLEAN_SIZE;
+        case 'string':
+            return STRING_OVERHEAD + value.length * 2;
+        case 'bigint':
+            return 16;
+        case 'symbol':
+            return STRING_OVERHEAD + String((_a = value.description) !== null && _a !== void 0 ? _a : '').length * 2;
+        default:
+            return 0;
+    }
+}
+/**
+ * Measures only the structure of the database handle registry `Map`
+ * (header, entry slots, and key strings). Registered object values are
+ * expected to be counted via the ownership graph instead.
+ *
+ * @param state - Shared walk state.
+ * @param registry - The database `_handleRegistry` map.
+ * @returns Estimated registry overhead in bytes, or `0` if already visited.
+ * @internal
+ */
+function measureHandleRegistryOverhead(state, registry) {
+    var e_2, _a;
+    if (state.visited.has(registry))
+        return 0;
+    state.visited.add(registry);
+    state.objectCount += 1;
+    // Objects are counted via the ownership graph; only Map structure + keys.
+    var bytes = MAP_OVERHEAD + registry.size * MAP_ENTRY_OVERHEAD;
+    try {
+        for (var _b = __values(registry.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var key = _c.value;
+            bytes += measurePrimitive(key);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    addBytes(state, 'handleRegistry', bytes, 1);
+    return bytes;
+}
+/**
+ * Recursively walks a value, attributing estimated bytes to the current
+ * category and optional entity type. Uses {@link WalkState.visited} to avoid
+ * recounting shared or cyclic references.
+ *
+ * @param state - Shared walk state.
+ * @param value - Value to measure.
+ * @param category - Ownership category for this value.
+ * @param entityType - Active entity type name when walking entity payload,
+ *   or `null` when outside an entity.
+ * @returns Estimated size in bytes for this subtree (also recorded in `state`).
+ * @internal
+ */
+function walkValue(state, value, category, entityType) {
+    var e_3, _a, e_4, _b, e_5, _c, e_6, _d;
+    if (value === null || value === undefined)
+        return 0;
+    var valueType = typeof value;
+    if (valueType === 'function')
+        return 0;
+    if (valueType !== 'object') {
+        var bytes_1 = measurePrimitive(value);
+        addBytes(state, category, bytes_1);
+        if (entityType) {
+            var bucket = ensureBucket(state.byEntityType, entityType);
+            bucket.bytes += bytes_1;
+        }
+        return bytes_1;
+    }
+    var obj = value;
+    // DOM / host objects
+    if (typeof obj.nodeType === 'number')
+        return 0;
+    if (state.visited.has(obj))
+        return 0;
+    state.visited.add(obj);
+    state.objectCount += 1;
+    if (!state.includeEventManagers && isAcCmEventManager(obj)) {
+        addBytes(state, category, OBJECT_OVERHEAD, 1);
+        return OBJECT_OVERHEAD;
+    }
+    var localEntityType = entityType;
+    var localCategory = category;
+    var isEntity = false;
+    if (obj instanceof AcDbEntity) {
+        isEntity = true;
+        localCategory = 'entities';
+        localEntityType = obj.type;
+        state.entityCount += 1;
+        var typeBucket = ensureBucket(state.byEntityType, localEntityType);
+        typeBucket.count += 1;
+    }
+    // Promise
+    if (typeof obj.then === 'function') {
+        addBytes(state, localCategory, OBJECT_OVERHEAD, 1);
+        return OBJECT_OVERHEAD;
+    }
+    // ArrayBuffer
+    if (obj instanceof ArrayBuffer) {
+        var bytes_2 = TYPED_ARRAY_OVERHEAD + obj.byteLength;
+        addBytes(state, localCategory, bytes_2, 1);
+        if (localEntityType) {
+            ensureBucket(state.byEntityType, localEntityType).bytes += bytes_2;
+        }
+        return bytes_2;
+    }
+    // TypedArray / DataView
+    if (isTypedArray(obj)) {
+        var bytes_3 = TYPED_ARRAY_OVERHEAD + obj.byteLength;
+        // Count underlying buffer only once via visited set when shared.
+        if (obj.buffer && !state.visited.has(obj.buffer)) {
+            state.visited.add(obj.buffer);
+        }
+        addBytes(state, localCategory, bytes_3, 1);
+        if (localEntityType) {
+            ensureBucket(state.byEntityType, localEntityType).bytes += bytes_3;
+        }
+        return bytes_3;
+    }
+    // Blob
+    if (typeof Blob !== 'undefined' && obj instanceof Blob) {
+        var bytes_4 = BLOB_OVERHEAD + obj.size;
+        addBytes(state, localCategory, bytes_4, 1);
+        if (localEntityType) {
+            ensureBucket(state.byEntityType, localEntityType).bytes += bytes_4;
+        }
+        return bytes_4;
+    }
+    // Date
+    if (obj instanceof Date) {
+        var bytes_5 = OBJECT_OVERHEAD + 8;
+        addBytes(state, localCategory, bytes_5, 1);
+        return bytes_5;
+    }
+    // Map — special-case handle registry values (already counted via ownership)
+    if (obj instanceof Map) {
+        var isHandleRegistry = localCategory === 'handleRegistry';
+        var structureBytes = MAP_OVERHEAD + obj.size * MAP_ENTRY_OVERHEAD;
+        var bytes_6 = structureBytes;
+        addBytes(state, localCategory, structureBytes, 1);
+        if (localEntityType) {
+            ensureBucket(state.byEntityType, localEntityType).bytes += structureBytes;
+        }
+        try {
+            for (var obj_1 = __values(obj), obj_1_1 = obj_1.next(); !obj_1_1.done; obj_1_1 = obj_1.next()) {
+                var _e = __read(obj_1_1.value, 2), k = _e[0], v = _e[1];
+                bytes_6 += walkValue(state, k, localCategory, localEntityType);
+                if (!isHandleRegistry) {
+                    bytes_6 += walkValue(state, v, localCategory, localEntityType);
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (obj_1_1 && !obj_1_1.done && (_a = obj_1.return)) _a.call(obj_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return bytes_6;
+    }
+    // Set
+    if (obj instanceof Set) {
+        var bytes_7 = SET_OVERHEAD + obj.size * SET_ENTRY_OVERHEAD;
+        try {
+            for (var obj_2 = __values(obj), obj_2_1 = obj_2.next(); !obj_2_1.done; obj_2_1 = obj_2.next()) {
+                var item = obj_2_1.value;
+                bytes_7 += walkValue(state, item, localCategory, localEntityType);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (obj_2_1 && !obj_2_1.done && (_b = obj_2.return)) _b.call(obj_2);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        addBytes(state, localCategory, SET_OVERHEAD + obj.size * SET_ENTRY_OVERHEAD, 1);
+        if (localEntityType) {
+            ensureBucket(state.byEntityType, localEntityType).bytes +=
+                SET_OVERHEAD + obj.size * SET_ENTRY_OVERHEAD;
+        }
+        return bytes_7;
+    }
+    // Array
+    if (Array.isArray(obj)) {
+        var bytes_8 = ARRAY_OVERHEAD + obj.length * POINTER_SIZE;
+        addBytes(state, localCategory, bytes_8, 1);
+        if (localEntityType) {
+            ensureBucket(state.byEntityType, localEntityType).bytes += bytes_8;
+        }
+        for (var i = 0; i < obj.length; i++) {
+            var child = obj[i];
+            var childCategory = resolveChildCategory(localCategory, String(i), child);
+            bytes_8 += walkValue(state, child, childCategory, localEntityType);
+        }
+        return bytes_8;
+    }
+    // Generic object / class instance
+    var bytes = OBJECT_OVERHEAD;
+    var keys = isPlainObject(obj)
+        ? Object.getOwnPropertyNames(obj)
+        : collectInstanceKeys(obj);
+    try {
+        // Property name strings + pointer slots
+        for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+            var key = keys_1_1.value;
+            bytes += POINTER_SIZE;
+            // Hidden class / property name cost amortized; count key string once lightly
+            bytes += Math.min(STRING_OVERHEAD + key.length * 2, 64);
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (keys_1_1 && !keys_1_1.done && (_c = keys_1.return)) _c.call(keys_1);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    addBytes(state, localCategory, bytes, 1);
+    if (localEntityType) {
+        ensureBucket(state.byEntityType, localEntityType).bytes += bytes;
+    }
+    if (isEntity) {
+        // Entity count already incremented; category count for entities tracks objects
+    }
+    try {
+        for (var keys_2 = __values(keys), keys_2_1 = keys_2.next(); !keys_2_1.done; keys_2_1 = keys_2.next()) {
+            var key = keys_2_1.value;
+            if (shouldSkipProperty(state, key, localCategory))
+                continue;
+            // Avoid walking back to owning database through private refs (cycle).
+            if (key === '_database' || key === 'database')
+                continue;
+            var child = void 0;
+            try {
+                child = obj[key];
+            }
+            catch (_f) {
+                continue;
+            }
+            if (typeof child === 'function')
+                continue;
+            // Dedicated handle-registry path: structure only
+            if (key === '_handleRegistry' && child instanceof Map) {
+                bytes += measureHandleRegistryOverhead(state, child);
+                continue;
+            }
+            var childCategory = resolveChildCategory(localCategory, key, child);
+            if (!state.includeTransactionManager &&
+                childCategory === 'transaction') {
+                continue;
+            }
+            if (!state.includeEventManagers && childCategory === 'events') {
+                continue;
+            }
+            bytes += walkValue(state, child, childCategory, localEntityType);
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (keys_2_1 && !keys_2_1.done && (_d = keys_2.return)) _d.call(keys_2);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    return bytes;
+}
+/**
+ * Estimates the in-memory footprint of an {@link AcDbDatabase} by walking its
+ * ownership graph and applying V8-inspired size heuristics.
+ *
+ * The estimate is reproducible and suitable for comparing drawings. It is not
+ * an exact Chrome / V8 heap retained size; expect roughly ±20–30% versus
+ * DevTools heap snapshots. Rendering GPU buffers and converter worker / WASM
+ * heaps are not included.
+ *
+ * @param db - Drawing database to measure (typically after `read` / `openUri`).
+ * @param options - Optional inclusion of transaction / event graphs.
+ * @returns Structured estimate with category and entity-type breakdowns.
+ *
+ * @example
+ * ```typescript
+ * const report = acdbEstimateDatabaseMemory(database)
+ * console.log(acdbFormatMemoryEstimate(report))
+ * ```
+ */
+export function acdbEstimateDatabaseMemory(db, options) {
+    var e_7, _a, e_8, _b;
+    var state = {
+        visited: new WeakSet(),
+        objectCount: 0,
+        entityCount: 0,
+        byCategory: new Map(),
+        byEntityType: new Map(),
+        includeTransactionManager: (options === null || options === void 0 ? void 0 : options.includeTransactionManager) === true,
+        includeEventManagers: (options === null || options === void 0 ? void 0 : options.includeEventManagers) === true
+    };
+    // Root walk starts as sysvars for db-owned scalars; tables/objects keys
+    // reclassify via resolveChildCategory.
+    walkValue(state, db, 'sysvars', null);
+    var totalBytes = 0;
+    var byCategory = {};
+    try {
+        for (var _c = __values(state.byCategory), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var _e = __read(_d.value, 2), key = _e[0], bucket = _e[1];
+            byCategory[key] = { bytes: bucket.bytes, count: bucket.count };
+            totalBytes += bucket.bytes;
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    var byEntityType = {};
+    try {
+        for (var _f = __values(state.byEntityType), _g = _f.next(); !_g.done; _g = _f.next()) {
+            var _h = __read(_g.value, 2), key = _h[0], bucket = _h[1];
+            byEntityType[key] = { bytes: bucket.bytes, count: bucket.count };
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    return {
+        totalBytes: totalBytes,
+        objectCount: state.objectCount,
+        entityCount: state.entityCount,
+        byCategory: byCategory,
+        byEntityType: byEntityType
+    };
+}
+/**
+ * Formats a byte count as a short human-readable string using binary units
+ * (`B`, `KiB`, or `MiB`).
+ *
+ * @param bytes - Non-negative byte count to format.
+ * @returns Formatted size string, for example `"512 B"` or `"2.00 KiB"`.
+ *
+ * @example
+ * ```typescript
+ * acdbFormatMemoryBytes(512)    // "512 B"
+ * acdbFormatMemoryBytes(2048)   // "2.00 KiB"
+ * ```
+ */
+export function acdbFormatMemoryBytes(bytes) {
+    if (bytes < 1024)
+        return "".concat(bytes, " B");
+    if (bytes < 1024 * 1024)
+        return "".concat((bytes / 1024).toFixed(2), " KiB");
+    return "".concat((bytes / (1024 * 1024)).toFixed(2), " MiB");
+}
+/**
+ * Formats an {@link AcDbMemoryEstimate} as multi-line text for console or UI
+ * output, including totals plus category and entity-type breakdowns sorted by
+ * descending byte size.
+ *
+ * @param report - Estimate produced by {@link acdbEstimateDatabaseMemory}.
+ * @returns Human-readable multi-line summary string.
+ *
+ * @example
+ * ```typescript
+ * const report = acdbEstimateDatabaseMemory(database)
+ * console.log(acdbFormatMemoryEstimate(report))
+ * ```
+ */
+export function acdbFormatMemoryEstimate(report) {
+    var e_9, _a, e_10, _b;
+    var lines = [
+        "AcDbDatabase memory estimate: ".concat(acdbFormatMemoryBytes(report.totalBytes), " (").concat(report.totalBytes, " bytes)"),
+        "Objects: ".concat(report.objectCount, ", Entities: ").concat(report.entityCount),
+        'By category:'
+    ];
+    var categories = Object.entries(report.byCategory).sort(function (a, b) { return b[1].bytes - a[1].bytes; });
+    try {
+        for (var categories_1 = __values(categories), categories_1_1 = categories_1.next(); !categories_1_1.done; categories_1_1 = categories_1.next()) {
+            var _c = __read(categories_1_1.value, 2), name_1 = _c[0], bucket = _c[1];
+            lines.push("  ".concat(name_1, ": ").concat(acdbFormatMemoryBytes(bucket.bytes), " (").concat(bucket.bytes, " bytes), count=").concat(bucket.count));
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (categories_1_1 && !categories_1_1.done && (_a = categories_1.return)) _a.call(categories_1);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+    var entityTypes = Object.entries(report.byEntityType).sort(function (a, b) { return b[1].bytes - a[1].bytes; });
+    if (entityTypes.length > 0) {
+        lines.push('By entity type:');
+        try {
+            for (var entityTypes_1 = __values(entityTypes), entityTypes_1_1 = entityTypes_1.next(); !entityTypes_1_1.done; entityTypes_1_1 = entityTypes_1.next()) {
+                var _d = __read(entityTypes_1_1.value, 2), name_2 = _d[0], bucket = _d[1];
+                lines.push("  ".concat(name_2, ": ").concat(acdbFormatMemoryBytes(bucket.bytes), " (").concat(bucket.bytes, " bytes), count=").concat(bucket.count));
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (entityTypes_1_1 && !entityTypes_1_1.done && (_b = entityTypes_1.return)) _b.call(entityTypes_1);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=AcDbMemoryEstimator.js.map