tosijs-ui 1.6.21 → 1.6.23

package/CHANGELOG.md

@@ -1,5 +1,102 @@
 # Changelog
 
+## 1.6.23
+
+**The two biggest sources of ecosystem-wide friction — runaway dev servers and haltija
+conflicts — fixed in the version people actually run.** If you use `tosijs-ui/site`, update.
+
+### Machine-safety guards (a leaking/forgotten dev server took a machine down twice)
+
+- **`killStrayServer` no longer `kill -9`s processes merely _connected_ to its port.** It freed
+  its port with `lsof -ti:PORT | xargs kill -9`, and `lsof -i:PORT` matches sockets whose local
+  **or remote** port is PORT — so it SIGKILLed every _client_ of that port, not just the
+  listener: the browser reading your page, an editor's language server, anything with a
+  connection. It now signals **only the process listening** on the port, only after confirming
+  it is a JS runtime, SIGTERM first and SIGKILL only as a fallback.
+
+- **Machine-health preflight** before each build and at dev-server launch (and on a 60s tick):
+  refuses to add load to a machine that is already dying — a runaway dev server, a VM stall.
+  Names the offending PIDs, sizes, ages and project dirs. **Local LLM runtimes (LM Studio,
+  ollama, llama.cpp, mlx_lm, vLLM, …) are exempt** — their memory shrinks the dev budget rather
+  than tripping the guard, and a big _non-dev_ process (Docker, a JVM, a database) only warns,
+  never fails. It never kills anything; it declines to _start_. `preflight: 'fail' | 'warn' |
+  false` in the site config, or `DEV_SKIP_PREFLIGHT=1`; auto-downgraded to a warning in CI.
+
+- **`idleTimeoutHours` (default 8)** — ⚠️ **behavior change:** the dev server now exits after 8
+  idle hours (no request, no rebuild). A forgotten dev server is not inert — it is a days-old
+  process still running the code it loaded at launch (updating the package does nothing for it).
+  `idleTimeoutHours: 0` disables it.
+
+- **RSS ceiling** (`memoryLimitMb`) sampled every 60s, and a **rebuild-loop detector** that
+  stops a build which writes a file it also watches instead of spawning a bundler forever.
+
+### haltija
+
+- Spawned as a **pinned range (`haltija@^1.4.0`)**, overridable with `HALTIJA_VERSION`, instead
+  of a floating `@latest` fetched fresh on every adopter's machine. The 1.4.0 floor is
+  deliberate: it routes `hj` by working directory (so a project's dev server drives its own
+  browser, not whichever was focused), never overwrites a newer machine-wide `hj`, and exits
+  non-zero on a failed command — which the doc-test lane now checks instead of racing to a
+  timeout. Teardown kills only its own process tree, never a haltija you were already running.
+
+### Also fixed
+
+- **Builds again against tosijs 1.6.9.** `<tosi-example>` detected hydration with a
+  `try { this.parts.js } catch` probe, which before tosijs 1.6.9 permanently poisoned the
+  `parts` proxy on the pre-hydration read it performed (it could blank the whole doc page), and
+  whose `private get hydrated()` collided with 1.6.9's new public `hydrated` (a `tsc` error, so
+  the package could not build against current tosijs). The probe is gone — it uses the base
+  class's `this.hydrated` now — and the tosijs floor moves to **`^1.6.9`**
+  ([tosijs#13](https://github.com/tonioloewald/tosijs/issues/13)).
+
+- **The doc-browser no longer double-suffixes the page `<title>`.** On path routing it re-derived
+  the title on hydration, ignoring `headTitle` and re-appending the project name to a title that
+  already contained it — so the home page flipped from its real title to `tosijs-ui — tosijs-ui`
+  the moment the bundle loaded. The static generator and the runtime now share **one**
+  `pageTitle` rule (case-insensitive, both-directions containment check; whitespace-only titles
+  and project names handled). Fixes [#6](https://github.com/tonioloewald/tosijs-ui/issues/6).
+
+- **Two more per-rebuild build leaks moved to child processes** (the dev server lives for days):
+  the live-example **check** (`new AsyncFunction` per block + a `Bun.Transpiler` per `ts` block)
+  and the bundle **gzip** (native zlib). Both now run in a child whose memory the OS reclaims on
+  exit; the gzip stays zlib-in-a-child (not the `gzip` CLI) so the reported size doesn't drift.
+
+## 1.6.22
+
+### Fixed
+
+- **The dev server no longer leaks memory on every rebuild — update as a priority if
+  you use `tosijs-ui/site`.** `buildSite()` called `Bun.build()` in-process, and Bun's
+  bundler never returns its native arena: RSS grows monotonically per call with no
+  plateau (40 sequential builds of one entry = **+367MB**, still climbing ~5MB/build at
+  the end), while the JS heap stays flat — so it is invisible to `Bun.gc()` and to any
+  heap profiler. `devServer()` calls it once per rebuild in a process that runs for
+  days, so it compounds: a ~2-day watch session reached **136GB RSS** and took the
+  machine down with it. Filed upstream as
+  [oven-sh/bun#34053](https://github.com/oven-sh/bun/issues/34053).
+
+  The bundle now builds in a **child process** (`bun build`), whose memory the OS
+  reclaims on exit — the same 15 bundles leave the parent **+0.5MB** instead of +192MB.
+  `buildEpub()` moved to a child too (happy-dom + `@resvg/resvg-js` are both native and
+  retaining, and it runs on every rebuild), with a 120s timeout kill so a hung or failed
+  ePub warns instead of wedging the rebuild. Measured on this repo's own dev server:
+  **baseline RSS 503MB → 150MB, and per-rebuild growth 26–59MB → ~2.7MB.**
+
+  Bundle output is byte-for-byte identical; this is purely where the work runs.
+
+### Added
+
+- **Dev-server memory watchdog.** `devServer()` now samples RSS after each rebuild and,
+  past a ceiling (`memoryLimitMb` in the site config, or `DEV_MEMORY_LIMIT_MB`; default
+  4096), prints the growth-per-rebuild and exits rather than let a leak thrash the
+  machine. It distinguishes real growth (a leak — report it) from a build whose baseline
+  simply exceeds the ceiling (raise the ceiling).
+
+## 1.6.21
+
+- Memory-routed nav-toggle fix; `buildSite` `.tjs` hooks (`libraryBuild`,
+  `generateCssPreload` — see BUILD-TJS-HOOK.md); tjs-lang 0.9.0.
+
 ## 1.6.20
 
 ### Fixed

package/dist/code-editor.d.ts

@@ -1,15 +1,7 @@
-import { Component as WebComponent, ElementCreator, PartsMap } from 'tosijs';
-import type { CmHandle } from './code-editor-cm';
-interface CodeEditorParts extends PartsMap {
-    host: HTMLDivElement;
-}
-export declare class CodeEditor extends WebComponent<CodeEditorParts> {
+import { Component as WebComponent, ElementCreator } from 'tosijs';
+export declare class CodeEditor extends WebComponent {
     static preferredTagName: string;
     private source;
-    private _handle;
-    private _loadPromise;
-    private _appliedMode;
-    private _appliedDisabled;
     get value(): string;
     set value(text: string);
     private _original;
@@ -20,16 +12,16 @@ export declare class CodeEditor extends WebComponent<CodeEditorParts> {
     showDiff(on: boolean): void;
     static initAttributes: {
         mode: string;
+        theme: string;
         disabled: boolean;
     };
     role: string;
-    /** The underlying CodeMirror EditorView (undefined until loaded). */
-    get editor(): CmHandle['view'] | undefined;
-    undo(): void;
-    redo(): void;
-    canUndo(): boolean;
-    canRedo(): boolean;
-    content: () => HTMLDivElement[];
+    private _ace;
+    private _editor;
+    private _editorPromise;
+    options: any;
+    get ace(): any;
+    get editor(): any;
     static shadowStyleSpec: {
         ':host': {
             display: string;
@@ -37,27 +29,9 @@ export declare class CodeEditor extends WebComponent<CodeEditorParts> {
             width: string;
             height: string;
         };
-        '[part="host"]': {
-            height: string;
-        };
-        '.cm-editor': {
-            height: string;
-        };
-        '.cm-scroller': {
-            outline: string;
-            fontFamily: string;
-        };
     };
     onResize(): void;
     connectedCallback(): void;
-    private isTjsMode;
-    /**
-     * When in tjs mode, lazily upgrade the editor to tjs-lang's CodeMirror language +
-     * autocomplete. No-op (keeps TS highlighting) if not tjs, if tjs-lang isn't
-     * installed, or if the mode/handle changed before the async load resolved.
-     */
-    private applyTjsExtension;
     render(): void;
 }
 export declare const codeEditor: ElementCreator<CodeEditor>;
-export {};

package/dist/code-editor.js

@@ -1,12 +1,12 @@
 /*#
 # code
 
-A [CodeMirror 6](https://codemirror.net/) wrapper.
+An [ACE Editor](https://ace.c9.io/) wrapper.
 
 Sometimes, it's nice to be able to just toss a code-editor in a web-page.
 
-`<tosi-code>`'s `value` is the code it contains. Its `mode` attribute sets the
-language (`javascript`, `typescript`, `tjs`, `css`, `html`, `markdown`).
+`<tosi-code>`'s `value` is the code it contains. Its `mode` attribute sets the language, and you can further configure
+the ACE editor instance via its `options` property.
 
 ```html
 <tosi-code style="width: 100%; height: 100%" mode="css">
@@ -16,33 +16,51 @@ body {
 </tosi-code>
 ```
 
-The `<tosi-code>` element has an `editor` property that gives you its CodeMirror
-[`EditorView`](https://codemirror.net/docs/ref/#view.EditorView), and
-`undo()` / `redo()` / `canUndo()` / `canRedo()` methods for history control.
-
-CodeMirror is loaded lazily on first use — a page with no `<tosi-code>` bundles
-none of it.
+The `<tosi-code>` element has an `editor` property that gives you its ACE editor instance,
+and an `ace` property that returns the `ace` module, giving you complete access to the
+[Ace API](https://ace.c9.io/api/index.html).
 */
 /*{ "parent": "Components" }*/
-import { Component as WebComponent, elements } from 'tosijs';
+import { Component as WebComponent } from 'tosijs';
+import { scriptTag } from './via-tag';
 import { tosiDiff } from './diff';
-const { div } = elements;
+const ACE_BASE_URL = 'https://cdnjs.cloudflare.com/ajax/libs/ace/1.23.2/';
+const DEFAULT_THEME = 'ace/theme/tomorrow';
+const getAce = async () => {
+    const { ace } = await scriptTag(`${ACE_BASE_URL}ace.min.js`);
+    return ace;
+};
+const makeCodeEditor = async (codeElement, mode = 'html', options = {}, theme = DEFAULT_THEME) => {
+    const ace = await getAce();
+    ace.config.set('basePath', ACE_BASE_URL);
+    const editor = ace.edit(codeElement, {
+        mode: `ace/mode/${mode}`,
+        tabSize: 2,
+        useSoftTabs: true,
+        useWorker: false,
+        // Wrap wide lines instead of scrolling horizontally; indentedSoftWrap keeps
+        // wrapped continuations aligned under the line's indent.
+        wrap: true,
+        indentedSoftWrap: true,
+        ...options,
+    });
+    editor.setTheme(theme);
+    return { ace, editor };
+};
 export class CodeEditor extends WebComponent {
     static preferredTagName = 'tosi-code';
     source = '';
-    _handle;
-    _loadPromise;
-    _appliedMode = '';
-    _appliedDisabled;
     get value() {
-        return this._handle ? this._handle.getValue() : this.source;
+        return this.editor === undefined ? this.source : this.editor.getValue();
     }
     set value(text) {
-        if (this._handle) {
-            this._handle.setValue(text);
+        if (this.editor === undefined) {
+            this.source = text;
         }
         else {
-            this.source = text;
+            this.editor.setValue(text);
+            this.editor.clearSelection();
+            this.editor.session.getUndoManager().reset();
         }
     }
     // Baseline for `showDiff()` — the version to diff the current `value` against.
@@ -54,9 +72,9 @@ export class CodeEditor extends WebComponent {
     set original(text) {
         this._original = text;
     }
-    // Diff overlay — built only on the editor's public surface (`value` + `original`)
-    // and the tosi-diff component, never the underlying editor's API, so it is
-    // editor-agnostic (this is why it survived the Ace → CodeMirror swap untouched).
+    // Diff overlay — deliberately built only on the editor's public surface
+    // (`value` + `original`) and the tosi-diff component, never the underlying
+    // editor's API, so it survives a future Ace → CodeMirror swap untouched.
     diffOverlay;
     get showingDiff() {
         return this.diffOverlay !== undefined && !this.diffOverlay.hidden;
@@ -85,27 +103,20 @@ export class CodeEditor extends WebComponent {
     }
     static initAttributes = {
         mode: 'javascript',
+        theme: DEFAULT_THEME,
         disabled: false,
     };
     role = 'code editor';
-    /** The underlying CodeMirror EditorView (undefined until loaded). */
-    get editor() {
-        return this._handle?.view;
+    _ace;
+    _editor;
+    _editorPromise;
+    options = {};
+    get ace() {
+        return this._ace;
     }
-    // History control — so consumers use these instead of reaching into `editor`.
-    undo() {
-        this._handle?.undo();
-    }
-    redo() {
-        this._handle?.redo();
-    }
-    canUndo() {
-        return this._handle?.canUndo() ?? false;
-    }
-    canRedo() {
-        return this._handle?.canRedo() ?? false;
+    get editor() {
+        return this._editor;
     }
-    content = () => [div({ part: 'host' })];
     static shadowStyleSpec = {
         ':host': {
             display: 'block',
@@ -113,71 +124,32 @@ export class CodeEditor extends WebComponent {
             width: '100%',
             height: '100%',
         },
-        '[part="host"]': { height: '100%' },
-        '.cm-editor': { height: '100%' },
-        '.cm-scroller': {
-            outline: 'none',
-            fontFamily: "Menlo, Monaco, Consolas, 'Courier New', monospace",
-        },
     };
     onResize() {
-        this._handle?.refresh();
+        if (this.editor !== undefined) {
+            this.editor.resize(true);
+        }
     }
     connectedCallback() {
         super.connectedCallback();
         if (this.source === '') {
             this.value = this.textContent !== null ? this.textContent.trim() : '';
         }
-        if (this._loadPromise === undefined) {
-            // Lazy chunk — CodeMirror only enters the bundle here, on first editor use.
-            this._loadPromise = import('./code-editor-cm').then(({ createCmEditor }) => {
-                const handle = createCmEditor(this.parts.host, {
-                    value: this.source,
-                    mode: this.mode,
-                    readOnly: this.disabled,
-                    root: this.shadowRoot ?? undefined,
-                    onChange: (value) => this.dispatchEvent(new CustomEvent('change', { detail: { value } })),
-                });
-                this._handle = handle;
-                this._appliedMode = this.mode;
-                this._appliedDisabled = this.disabled;
-                this.applyTjsExtension();
-                return handle;
+        if (this._editorPromise === undefined) {
+            this._editorPromise = makeCodeEditor(this, this.mode, this.options, this.theme);
+            this._editorPromise.then(({ ace, editor }) => {
+                this._ace = ace;
+                this._editor = editor;
+                editor.setValue(this.source, 1);
+                editor.clearSelection();
+                editor.session.getUndoManager().reset();
             });
         }
     }
-    isTjsMode() {
-        return this.mode === 'tjs' || this.mode === 'ajs';
-    }
-    /**
-     * When in tjs mode, lazily upgrade the editor to tjs-lang's CodeMirror language +
-     * autocomplete. No-op (keeps TS highlighting) if not tjs, if tjs-lang isn't
-     * installed, or if the mode/handle changed before the async load resolved.
-     */
-    applyTjsExtension() {
-        const handle = this._handle;
-        if (!handle || !this.isTjsMode())
-            return;
-        import('./code-editor-cm')
-            .then(({ loadTjsExtension }) => loadTjsExtension())
-            .then((ext) => {
-            if (ext && this._handle === handle && this.isTjsMode()) {
-                handle.setLanguageExtension(ext);
-            }
-        });
-    }
     render() {
         super.render();
-        if (this._handle) {
-            if (this.disabled !== this._appliedDisabled) {
-                this._handle.setReadOnly(this.disabled);
-                this._appliedDisabled = this.disabled;
-            }
-            if (this.mode !== this._appliedMode) {
-                this._handle.setMode(this.mode);
-                this._appliedMode = this.mode;
-                this.applyTjsExtension();
-            }
+        if (this._editorPromise !== undefined) {
+            this._editorPromise.then(({ editor }) => editor.setReadOnly(this.disabled));
         }
     }
 }

package/dist/doc-browser.js

@@ -155,6 +155,7 @@ import { elements, vars, varDefault, bindings, touch, getListItem, debounce, tos
 import { buildSlugMap, pathForSlug, filenameForPath } from './doc-system/routing';
 import { buildNavTree } from './doc-system/nav-tree';
 import { renderDocMarkdown } from './doc-system/render';
+import { pageTitle } from './doc-system/doc-title';
 import { LiveExample, testManager } from './live-example';
 import { tosiSidenav, TosiSidenav } from './side-nav';
 import { icons } from './icons';
@@ -613,9 +614,11 @@ export function createDocBrowser(options) {
         LiveExample.insertExamples(docContent, context, doc.path || undefined);
         scrollToHashExample();
         if (routing === 'path') {
-            document.title = projectName
-                ? `${doc.title} — ${projectName}`
-                : doc.title;
+            // The SAME rule the static generator used for this page's <head> (doc-title.ts).
+            // This used to re-derive it — ignoring `headTitle` and re-suffixing a title that
+            // already ended in the project name — so the home page's title flipped to
+            // "tosijs-ui — tosijs-ui" the moment the bundle loaded (issue #6).
+            document.title = pageTitle(doc, projectName);
         }
     };
     // Always resolve to the RAW doc from the original array — docs reached via the

package/dist/doc-system/doc-title.d.ts

@@ -0,0 +1,19 @@
+/** The fields of a Doc that bear on its title. Structural, so both callers fit. */
+export interface TitledDoc {
+    title: string;
+    /** verbatim <title>, no project suffix — a per-doc override */
+    headTitle?: string;
+}
+/**
+ * `headTitle` wins verbatim. Otherwise suffix the project name — but only when the two
+ * are genuinely distinct.
+ *
+ * "Distinct" means **neither string contains the other, compared case-insensitively.**
+ * A one-way, case-sensitive `title.includes(projectName)` check missed real cases: a
+ * project titled `Tosijs-UI` against a doc titled `tosijs-ui` (case), and a doc whose
+ * title is a *substring* of the project name (the containment runs the other way). Any
+ * of those, suffixed, reads as redundant — "tosijs-ui — tosijs-ui" being the one that
+ * shipped (issue #6). When one already contains the other, the doc's own title is the
+ * more specific label, so use it alone.
+ */
+export declare function pageTitle(doc: TitledDoc, projectName?: string): string;

package/dist/doc-system/doc-title.js

@@ -0,0 +1,51 @@
+/*
+The ONE rule for a doc page's <title>.
+
+It has to be one rule, because it is applied twice — once by the static generator into
+the pre-rendered `<head>`, and once by the doc-browser when it hydrates. Two
+independently-written copies drifted, and the title became the one thing on the page
+that visibly MOVED on hydration:
+
+    JS off        →  "tosijs-ui — robust, dependency-free web components"   (headTitle)
+    hydrated      →  "tosijs-ui — tosijs-ui"                                (!)
+
+...because the runtime copy ignored `headTitle` and re-suffixed a title that already
+ended in the project name. That is GitHub issue #6, and it was live on our own home
+page while this release's whole thesis was "hydration is purely additive, nothing
+moves".
+
+Shared by `site/generate-site.ts` (build) and `doc-browser.ts` (runtime). Pure — no DOM,
+no Bun — so both can import it.
+*/
+/**
+ * `headTitle` wins verbatim. Otherwise suffix the project name — but only when the two
+ * are genuinely distinct.
+ *
+ * "Distinct" means **neither string contains the other, compared case-insensitively.**
+ * A one-way, case-sensitive `title.includes(projectName)` check missed real cases: a
+ * project titled `Tosijs-UI` against a doc titled `tosijs-ui` (case), and a doc whose
+ * title is a *substring* of the project name (the containment runs the other way). Any
+ * of those, suffixed, reads as redundant — "tosijs-ui — tosijs-ui" being the one that
+ * shipped (issue #6). When one already contains the other, the doc's own title is the
+ * more specific label, so use it alone.
+ */
+export function pageTitle(doc, projectName) {
+    // A whitespace-only `headTitle` is not an override, it's a blank <title> — trim it
+    // and fall through. Trimming also cleans up an accidentally-padded one ("verbatim"
+    // means "no project suffix", not "keep your stray whitespace").
+    const headTitle = doc.headTitle?.trim();
+    if (headTitle)
+        return headTitle;
+    // Trim first: a whitespace-only name ('' or '   ') is "no project name", not a real
+    // one. Untrimmed, ' ' is truthy and slips through — and worse, `title.includes(' ')`
+    // is true for any multi-word title, so it would silently suppress a suffix that
+    // should appear. Trimming also strips a padded 'tosijs-ui ' down to the real name.
+    const project = projectName?.trim() ?? '';
+    if (!project)
+        return doc.title;
+    const t = doc.title.toLowerCase();
+    const p = project.toLowerCase();
+    if (t.includes(p) || p.includes(t))
+        return doc.title;
+    return `${doc.title} — ${project}`;
+}

package/dist/doc-system/site/check-examples-cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/doc-system/site/check-examples-cli.js

@@ -0,0 +1,39 @@
+/*
+Live-example build check — the subprocess entry point for checkExamples().
+
+Why a child process, when this is "just" compiling some strings:
+
+checkExamples() compiles EVERY executable block in the corpus (83 of them here) with
+`new AsyncFunction(js)` on EVERY dev rebuild, and — for `ts` blocks — runs them
+through a `Bun.Transpiler`. Both retain memory the JS heap never shows you:
+
+  - JSC caches compiled code, KEYED BY SOURCE TEXT. That last part is the trap: replay
+    the same corpus and RSS plateaus (the cache dedups), so a leak test on an unchanged
+    corpus reports "flat" and lies. But a dev server only rebuilds BECAUSE A FILE
+    CHANGED — the source is fresh every time, so nothing dedups and it never plateaus.
+    Measured with fresh sources: +7.1MB over 40 rebuilds, still climbing.
+  - `Bun.Transpiler` strands ~40KB per construction (oven-sh/bun#34053).
+
+In a process that lives for days across thousands of rebuilds, that is unbounded. The
+child hands all of it back to the OS on exit. Same reasoning — and the same fix — as
+the bundle step, the ePub step, and generate-css; see the Bun.build note in
+orchestrator.ts.
+
+  bun check-examples-cli.ts <docs.json> [contextKey ...]
+  → writes ExampleProblem[] as JSON to stdout; exit 0 whether or not problems were
+    found (a problem is data, not a crash — only a real failure exits non-zero).
+
+Build-time only. Never import this from browser code.
+*/
+import { checkExamples } from './check-examples';
+const docsJson = process.argv[2];
+if (!docsJson) {
+    console.error('check-examples-cli: expected a docs.json path');
+    process.exit(1);
+}
+const contextKeys = process.argv.slice(3);
+const corpus = JSON.parse(await Bun.file(docsJson).text());
+const problems = await checkExamples(corpus, contextKeys.length ? { contextKeys } : {});
+// stdout is the channel — the parent parses this. Anything else this process prints
+// (warnings from the transform, say) goes to stderr so it can't corrupt the payload.
+process.stdout.write(JSON.stringify(problems));

package/dist/doc-system/site/dev-server.d.ts

@@ -2,6 +2,32 @@ import type { SiteConfig } from './site-config';
 declare global {
     var Bun: any;
 }
+/**
+ * Resolve the idle-exit timeout to milliseconds (0 = disabled).
+ *
+ * Env wins over config, config over the default. An unparseable value falls back
+ * to the default rather than to 0: a typo'd `DEV_IDLE_TIMEOUT_HOURS=8h` must not
+ * silently turn the guard OFF — that is the exact failure it exists to prevent.
+ * Only an explicit non-positive number disables it.
+ */
+export declare function resolveIdleMs(configHours: number | undefined, envHours: string | undefined): number;
+/**
+ * Resolve the RSS ceiling in MB (0 = disabled).
+ *
+ * Same rule as `resolveIdleMs`, and it was NOT being applied: the ceiling was read as
+ * `Number(env ?? config ?? 4096)`, which fails in both directions at once —
+ *
+ *   DEV_MEMORY_LIMIT_MB=''   → `??` passes '' through → Number('') === 0 → the ceiling
+ *                              is ZERO, so `rss >= limit` is true on the first sample
+ *                              and the dev server kills itself on every rebuild.
+ *   DEV_MEMORY_LIMIT_MB=4gb  → NaN → every `>=` comparison is false → the guard is
+ *                              silently OFF, on the machine of someone who was
+ *                              explicitly trying to configure it.
+ *
+ * An empty env var is *unset*, not zero. Garbage falls back to the default, never to
+ * off. Only an explicit non-positive number disables the ceiling.
+ */
+export declare function resolveLimitMb(configMb: number | undefined, envMb: string | undefined): number;
 export declare function devServer(config: SiteConfig, opts?: {
     test?: boolean;
     build?: () => unknown | Promise<unknown>;