vintage-frames 0.5.5 → 0.5.6

package/custom-elements.json

@@ -17285,10 +17285,46 @@
                 "text": "boolean"
               },
               "default": "false",
-              "description": "Show a grow box at the bottom-right corner for resizing.",
+              "description": "Show a grow box at the bottom-right corner for resizing. The drag is\nbounded per axis by the sizeRect below.",
               "attribute": "resizable",
               "reflects": true
             },
+            {
+              "kind": "field",
+              "name": "minWidth",
+              "type": {
+                "text": "number | null | undefined"
+              },
+              "description": "The sizeRect: the range of sizes the grow box can drag the window to,\nper axis, in whole system px — GrowWindow's, where the app stated the\nrectangle and the Window Manager clamped the drag to it. `minWidth` and\n`minHeight` default to the 80×54 floor a window can still be worked at;\nthe maxes are unbounded. A min equal to its max locks that axis —\n`min-height=\"67\" max-height=\"67\"` on a strip that scrolls sideways and\nnever grows taller, so the grow box changes the width alone.\n\nBounds the gesture only: an authored `width`/`height` outside the rect\nrenders as declared, and the first grow-box move brings it inside. The\nclamp runs after the drag's lattice snap, so a bound lands exactly the\nway an authored size does, even off the lattice (an odd height at 2×);\nwhere a min and max cross, the max wins, so a window held under the\nfloor stays put instead of jumping to it.",
+              "attribute": "min-width"
+            },
+            {
+              "kind": "field",
+              "name": "minHeight",
+              "type": {
+                "text": "number | null | undefined"
+              },
+              "description": "See minWidth. Default 54.",
+              "attribute": "min-height"
+            },
+            {
+              "kind": "field",
+              "name": "maxWidth",
+              "type": {
+                "text": "number | null | undefined"
+              },
+              "description": "See minWidth. Unbounded by default.",
+              "attribute": "max-width"
+            },
+            {
+              "kind": "field",
+              "name": "maxHeight",
+              "type": {
+                "text": "number | null | undefined"
+              },
+              "description": "See minWidth. Unbounded by default.",
+              "attribute": "max-height"
+            },
             {
               "kind": "field",
               "name": "flush",
@@ -17667,9 +17703,41 @@
                 "text": "boolean"
               },
               "default": "false",
-              "description": "Show a grow box at the bottom-right corner for resizing.",
+              "description": "Show a grow box at the bottom-right corner for resizing. The drag is\nbounded per axis by the sizeRect below.",
               "fieldName": "resizable"
             },
+            {
+              "name": "min-width",
+              "type": {
+                "text": "number | null | undefined"
+              },
+              "description": "The sizeRect: the range of sizes the grow box can drag the window to,\nper axis, in whole system px — GrowWindow's, where the app stated the\nrectangle and the Window Manager clamped the drag to it. `minWidth` and\n`minHeight` default to the 80×54 floor a window can still be worked at;\nthe maxes are unbounded. A min equal to its max locks that axis —\n`min-height=\"67\" max-height=\"67\"` on a strip that scrolls sideways and\nnever grows taller, so the grow box changes the width alone.\n\nBounds the gesture only: an authored `width`/`height` outside the rect\nrenders as declared, and the first grow-box move brings it inside. The\nclamp runs after the drag's lattice snap, so a bound lands exactly the\nway an authored size does, even off the lattice (an odd height at 2×);\nwhere a min and max cross, the max wins, so a window held under the\nfloor stays put instead of jumping to it.",
+              "fieldName": "minWidth"
+            },
+            {
+              "name": "min-height",
+              "type": {
+                "text": "number | null | undefined"
+              },
+              "description": "See minWidth. Default 54.",
+              "fieldName": "minHeight"
+            },
+            {
+              "name": "max-width",
+              "type": {
+                "text": "number | null | undefined"
+              },
+              "description": "See minWidth. Unbounded by default.",
+              "fieldName": "maxWidth"
+            },
+            {
+              "name": "max-height",
+              "type": {
+                "text": "number | null | undefined"
+              },
+              "description": "See minWidth. Unbounded by default.",
+              "fieldName": "maxHeight"
+            },
             {
               "name": "flush",
               "type": {

package/dist/components/vf-window.d.ts

@@ -92,8 +92,34 @@ export declare class VfWindow extends VfWindow_base {
     zoomable: boolean;
     /** Allow dragging the window by its title bar. */
     movable: boolean;
-    /** Show a grow box at the bottom-right corner for resizing. */
+    /**
+     * Show a grow box at the bottom-right corner for resizing. The drag is
+     * bounded per axis by the sizeRect below.
+     */
     resizable: boolean;
+    /**
+     * The sizeRect: the range of sizes the grow box can drag the window to,
+     * per axis, in whole system px — GrowWindow's, where the app stated the
+     * rectangle and the Window Manager clamped the drag to it. `minWidth` and
+     * `minHeight` default to the 80×54 floor a window can still be worked at;
+     * the maxes are unbounded. A min equal to its max locks that axis —
+     * `min-height="67" max-height="67"` on a strip that scrolls sideways and
+     * never grows taller, so the grow box changes the width alone.
+     *
+     * Bounds the gesture only: an authored `width`/`height` outside the rect
+     * renders as declared, and the first grow-box move brings it inside. The
+     * clamp runs after the drag's lattice snap, so a bound lands exactly the
+     * way an authored size does, even off the lattice (an odd height at 2×);
+     * where a min and max cross, the max wins, so a window held under the
+     * floor stays put instead of jumping to it.
+     */
+    minWidth?: number | null;
+    /** See {@link minWidth}. Default 54. */
+    minHeight?: number | null;
+    /** See {@link minWidth}. Unbounded by default. */
+    maxWidth?: number | null;
+    /** See {@link minWidth}. Unbounded by default. */
+    maxHeight?: number | null;
     /**
      * Remove the default 12px body padding. Under `scrollbars` the body has
      * none to remove, so the flag reaches the built-in scroll area instead

package/dist/components/vf-window.js

@@ -18,13 +18,18 @@ import "./vf-scroll-area.js";
 import { LitElement as N, css as P, html as F, nothing as I } from "lit";
 import { property as L, state as R } from "lit/decorators.js";
 //#region src/components/vf-window.ts
-var z = 80, B = 54, V = 24, H = 8, U = class extends E(c(N)) {
+var z = 80, B = 54;
+function V(e, t, n) {
+	let r = Math.max(t, e);
+	return n == null ? r : Math.min(n, r);
+}
+var H = 24, U = 8, W = class extends E(c(N)) {
 	constructor(...e) {
 		super(...e), this.heading = "", this.active = !0, this.closable = !0, this.zoomable = !1, this.movable = !1, this.resizable = !1, this.flush = !1, this._hasStatus = !1, this.scale = new n(this), this.gridSnap = new T(this), this.titleCenter = new O(this), this._dotsPattern = "", this.#e = new x(), this.#t = (e, t, n) => {
 			let r = a(this.offsetWidth, this);
 			return {
-				x: Math.min(Math.max(e, V - r), n.width - V),
-				y: Math.min(Math.max(t, 0), Math.max(0, n.height - V))
+				x: Math.min(Math.max(e, H - r), n.width - H),
+				y: Math.min(Math.max(t, 0), Math.max(0, n.height - H))
 			};
 		}, this._placement = new s(this, (e, t, n) => this.#t(e, t, n)), this._drag = new D(this, {
 			onDragStart: (e) => !this.movable || e.button !== 0 || e.composedPath().some((e) => e instanceof HTMLElement && e.classList.contains("box")) ? null : (this.#i(), this._placement.seed()),
@@ -295,7 +300,7 @@ var z = 80, B = 54, V = 24, H = 8, U = class extends E(c(N)) {
 			rows: 1,
 			tile: p
 		});
-		let t = Math.ceil((e + d) / p) * p, n = H + d;
+		let t = Math.ceil((e + d) / p) * p, n = U + d;
 		return F`<div
       class="vf-tile-raster"
       style="width:${i(t)};height:${i(n)};background-image:${this.#e.for(d, d, f, t, n)}"
@@ -350,7 +355,7 @@ var z = 80, B = 54, V = 24, H = 8, U = class extends E(c(N)) {
 	_onGrowPointerMove(e) {
 		let t = this._resizeState;
 		if (!t || e.pointerId !== t.pointerId) return;
-		let n = r(Math.max(z, t.baseWidth + a(e.clientX - t.startX, this)), this), i = r(Math.max(B, t.baseHeight + a(e.clientY - t.startY, this)), this);
+		let n = V(r(t.baseWidth + a(e.clientX - t.startX, this), this), this.minWidth ?? z, this.maxWidth), i = V(r(t.baseHeight + a(e.clientY - t.startY, this), this), this.minHeight ?? B, this.maxHeight);
 		(n !== this.width || i !== this.height) && (t.emitPending = !0, t.resized = !0), this.width = n, this.height = i;
 	}
 	_onGrowPointerEnd(t) {
@@ -409,24 +414,36 @@ var z = 80, B = 54, V = 24, H = 8, U = class extends E(c(N)) {
     `;
 	}
 };
-o([L({ reflect: !0 })], U.prototype, "variant", void 0), o([L()], U.prototype, "heading", void 0), o([L({
+o([L({ reflect: !0 })], W.prototype, "variant", void 0), o([L()], W.prototype, "heading", void 0), o([L({
 	type: Boolean,
 	reflect: !0
-})], U.prototype, "active", void 0), o([L({
+})], W.prototype, "active", void 0), o([L({
 	type: Boolean,
 	reflect: !0
-})], U.prototype, "closable", void 0), o([L({
+})], W.prototype, "closable", void 0), o([L({
 	type: Boolean,
 	reflect: !0
-})], U.prototype, "zoomable", void 0), o([L({
+})], W.prototype, "zoomable", void 0), o([L({
 	type: Boolean,
 	reflect: !0
-})], U.prototype, "movable", void 0), o([L({
+})], W.prototype, "movable", void 0), o([L({
 	type: Boolean,
 	reflect: !0
-})], U.prototype, "resizable", void 0), o([L({
+})], W.prototype, "resizable", void 0), o([L({
+	type: Number,
+	attribute: "min-width"
+})], W.prototype, "minWidth", void 0), o([L({
+	type: Number,
+	attribute: "min-height"
+})], W.prototype, "minHeight", void 0), o([L({
+	type: Number,
+	attribute: "max-width"
+})], W.prototype, "maxWidth", void 0), o([L({
+	type: Number,
+	attribute: "max-height"
+})], W.prototype, "maxHeight", void 0), o([L({
 	type: Boolean,
 	reflect: !0
-})], U.prototype, "flush", void 0), o([L({ reflect: !0 })], U.prototype, "scrollbars", void 0), o([R()], U.prototype, "_hasStatus", void 0), U = o([t("vf-window")], U);
+})], W.prototype, "flush", void 0), o([L({ reflect: !0 })], W.prototype, "scrollbars", void 0), o([R()], W.prototype, "_hasStatus", void 0), W = o([t("vf-window")], W);
 //#endregion
-export { U as VfWindow };
+export { W as VfWindow };

package/docs/SPEC.md

@@ -208,7 +208,7 @@ Full-bleed classic desktop container.
 
 #### `vf-window` (`VfWindow`, vf-window.ts)
 The desktop-window shell: the classic document window (see DragThing screenshot), parameterized down to the windoid (see the Group A recipe table).
-- **Attributes/props:** `heading: string` (title text), `width: number` / `height: number` (**declare them both** — whole system px, so the window keeps its proportion to the chrome inside it at every density. A window is a fixed box in both axes, the way a WIND resource was: one that grows with its body is one the user can neither predict nor control via the grow box. Each missing dimension falls back to something different — width to block layout, height to the content — and the window names whichever are missing, once, in the console), `active: boolean` (default **true**; reflect), `closable: boolean` (default true), `zoomable: boolean` (default false), `movable: boolean` (default false), `resizable: boolean` (default false), `flush: boolean` (default false — removes the body padding; under `scrollbars`, the built-in viewport's 8px inset instead), `variant?: 'utility'` (the slim windoid chrome), `scrollbars?: 'vertical' | 'horizontal' | 'both'` (edge scroll rails).
+- **Attributes/props:** `heading: string` (title text), `width: number` / `height: number` (**declare them both** — whole system px, so the window keeps its proportion to the chrome inside it at every density. A window is a fixed box in both axes, the way a WIND resource was: one that grows with its body is one the user can neither predict nor control via the grow box. Each missing dimension falls back to something different — width to block layout, height to the content — and the window names whichever are missing, once, in the console), `active: boolean` (default **true**; reflect), `closable: boolean` (default true), `zoomable: boolean` (default false), `movable: boolean` (default false), `resizable: boolean` (default false), `min-width` / `min-height: number` (default 80 / 54) and `max-width` / `max-height: number` (unbounded) — the grow box's sizeRect, whole system px (see Behavior), `flush: boolean` (default false — removes the body padding; under `scrollbars`, the built-in viewport's 8px inset instead), `variant?: 'utility'` (the slim windoid chrome), `scrollbars?: 'vertical' | 'horizontal' | 'both'` (edge scroll rails).
 - **Visual:** `vfChromeFrame` + `vfTitleBar` (§4), plus a full-size flex-column layout on the frame. `display: block`. Sets `--vf-surface: var(--vf-white, #fff)` on itself.
   - Title bar: from `vfTitleBar` — height `var(--vf-titlebar-height, 18px)`, white bg, bottom `1px solid black`, contains `.vf-stripes` layer (only when `active`). `touch-action: none` only when `[movable]`.
   - Title: centered, bold, on a white patch (`padding: 0 6px`; cap band on interior rows 4..12, 7px of white between ink and stripes — see §4 `vfTitleBar` for the traced geometry and the lattice hold) above the stripes, with `--vf-title-inset: 60px` of clearance so it ellipsizes before reaching the widgets. Inactive: no stripes, widgets undrawn (transparent ink — they keep their tab stops; see A11y below), the grow box's nested squares hidden, and every managed scroll rail inside the window blanked (see "always-a-rail" §5 vf-scroll-area) — but the title text stays black (System 7 never grayed the window title).
@@ -220,7 +220,7 @@ The desktop-window shell: the classic document window (see DragThing screenshot)
   - Edge scroll rails (if `scrollbars`): the body slot renders inside a shadow `vf-scroll-area` (its `axis` = the attribute's value, `label` = the heading, `viewport` part re-exported) carrying the TeachText composition internally — `calc(100% + 2px·scale)` with `margin: -1px·scale`, one system px under the frame on every side, so the area's own frame border repaints the window's border lines and a `resizable` window's grow box (z-index 1) lands exactly over the rail-corner cell. `flush` passes through to the area (its viewport drops the 8px inset, keeping the border-floor term, so content and the (0,0) of placed children sit at the content region's corner); a `resizable` window sets the area's `corner`, so a single-axis rail stops at the corner cell too — unless the status strip is populated, when the grow box sits in the strip and the rail runs edge to edge onto the strip's rule. Same caveats as the slotted composition (see vf-scroll-area §5), which remains supported for inset wells.
   - Utility variant (`variant="utility"`): the slim windoid bar traced from `Windows/utility-window.png` — `--vf-titlebar-height-utility` (12px = 11px interior + 1px rule), the `vfDots` dither instead of stripes (flush to the side borders — see §4 vfDots), 7×7 widgets (`top: 2px`; close `left: 7px`, zoom `right: 8px` — the art is asymmetric by that pixel) with a 2px patch ring where the striped bar's is 1px (`--vf-widget-ring`, internal geometry: the windoid sheet clears two px of dither beside its widgets), and the nested zoom square shrunk so its edges land at sprite col/row 3. No title patch: the display face's 16px line box can't sit in an 11px interior, so `.vf-title` is `display: none` under the variant (a retheming consumer can re-show it via `::part(title)`) and the heading names the widgets. A pressed windoid widget inverts whole — black interior under a white (invisible) borderline — rather than flashing the big bar's 9×9 sunburst, which can't land on a 5×5 interior.
 - **A11y:** the close/zoom `aria-label`s are qualified by the title when there is one (`Close ${heading}` / `Zoom ${heading}`, falling back to bare `Close` / `Zoom`) — several windows are open at once by design, so a bare repeated "Close" gives an AT user no way to tell which window a widget belongs to. The frame is `role="group"`, named by the title patch via `aria-labelledby` when there is a heading (the utility variant's hidden patch still names it — AccName resolves hidden labelledby targets) — `group` rather than `region` deliberately, so a desktop of windows doesn't pollute landmark navigation; the title bar is a `<div>`, never a `<header>`, which would map to an unnamed `banner` landmark even inside the shadow root. An inactive window's widgets stay in the tree and the tab order but paint no ink (transparent border/background/patch ring — the bare System 7 bar): a background window whose body holds nothing focusable is still reachable, activated by `vf-desktop`'s `focusin` raise the moment Tab lands on a widget, and never drops focus to `<body>` when it deactivates. `npm run verify:window-a11y`.
-- **Behavior:** close box click → `vf-close` (does NOT remove itself; consumer decides). Zoom box click → `vf-zoom`. If `movable`: dragging the title bar moves the window — the drag seeds its origin from the current offset position (once, converting to system px) and then states `left`/`top` via pointer capture, in whole system px like any authored placement. If `resizable`: dragging the grow box states `width`/`height` the same way, and fires `vf-resize` (detail `{ width, height, commit }`, sizes in whole system px) — one event per size the drag actually writes (`commit: false`), fired *after* the new box is applied so a handler that measures reads the resized layout, then a final `commit: true` as the gesture settles (release or cancel), only when it changed the size. Window content can follow the grow box from this event alone, no ResizeObserver. Fired by the gesture only: a programmatic `width`/`height` write fires nothing, the way a value set fires no `vf-change`.
+- **Behavior:** close box click → `vf-close` (does NOT remove itself; consumer decides). Zoom box click → `vf-zoom`. If `movable`: dragging the title bar moves the window — the drag seeds its origin from the current offset position (once, converting to system px) and then states `left`/`top` via pointer capture, in whole system px like any authored placement. If `resizable`: dragging the grow box states `width`/`height` the same way, each axis clamped into the sizeRect (`min-width`/`max-width`, `min-height`/`max-height` — GrowWindow's: the app stated the rectangle of sizes and the Window Manager clamped the drag to it; the mins default to the 80×54 floor a window can still be worked at, the maxes are unbounded, and a min equal to its max locks the axis — the strip that scrolls sideways and never grows taller). The clamp runs after the lattice snap, so a bound lands exactly the way an authored size does even off the lattice (an odd height at 2×); where a min and max cross the max wins, so a window authored under the floor and held there never jumps to it. The rect bounds the gesture only: a size authored outside it renders as declared, and the first grow-box move brings it inside. The drag fires `vf-resize` (detail `{ width, height, commit }`, sizes in whole system px) — one event per size the drag actually writes (`commit: false`), fired *after* the new box is applied so a handler that measures reads the resized layout, then a final `commit: true` as the gesture settles (release or cancel), only when it changed the size. Window content can follow the grow box from this event alone, no ResizeObserver. Fired by the gesture only: a programmatic `width`/`height` write fires nothing, the way a value set fires no `vf-change`.
 - **Slots:** default (body content), `status` (the bottom status strip — see Visual).
 - **Parts:** `frame`, `title-bar`, `title`, `close-box`, `zoom-box`, `body`, `status-bar`, `grow-box`, plus `viewport` re-exported from the built-in scroll area when `scrollbars` is set.
 - **Events:** `vf-close`, `vf-zoom` (detail `{}`), `vf-resize` (detail `{ width, height, commit }`).

package/editor/vscode.html-custom-data.json

@@ -1361,7 +1361,27 @@
         },
         {
           "name": "resizable",
-          "description": "Show a grow box at the bottom-right corner for resizing.",
+          "description": "Show a grow box at the bottom-right corner for resizing. The drag is\nbounded per axis by the sizeRect below.",
+          "values": []
+        },
+        {
+          "name": "min-width",
+          "description": "The sizeRect: the range of sizes the grow box can drag the window to,\nper axis, in whole system px — GrowWindow's, where the app stated the\nrectangle and the Window Manager clamped the drag to it. `minWidth` and\n`minHeight` default to the 80×54 floor a window can still be worked at;\nthe maxes are unbounded. A min equal to its max locks that axis —\n`min-height=\"67\" max-height=\"67\"` on a strip that scrolls sideways and\nnever grows taller, so the grow box changes the width alone.\n\nBounds the gesture only: an authored `width`/`height` outside the rect\nrenders as declared, and the first grow-box move brings it inside. The\nclamp runs after the drag's lattice snap, so a bound lands exactly the\nway an authored size does, even off the lattice (an odd height at 2×);\nwhere a min and max cross, the max wins, so a window held under the\nfloor stays put instead of jumping to it.",
+          "values": []
+        },
+        {
+          "name": "min-height",
+          "description": "See minWidth. Default 54.",
+          "values": []
+        },
+        {
+          "name": "max-width",
+          "description": "See minWidth. Unbounded by default.",
+          "values": []
+        },
+        {
+          "name": "max-height",
+          "description": "See minWidth. Unbounded by default.",
           "values": []
         },
         {

package/editor/web-types.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/JetBrains/web-types/master/schema/web-types.json",
   "name": "vintage-frames",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "description-markup": "markdown",
   "contributions": {
     "html": {
@@ -3290,9 +3290,29 @@
             },
             {
               "name": "resizable",
-              "description": "Show a grow box at the bottom-right corner for resizing.",
+              "description": "Show a grow box at the bottom-right corner for resizing. The drag is\nbounded per axis by the sizeRect below.",
               "value": { "type": "boolean", "default": "false" }
             },
+            {
+              "name": "min-width",
+              "description": "The sizeRect: the range of sizes the grow box can drag the window to,\nper axis, in whole system px — GrowWindow's, where the app stated the\nrectangle and the Window Manager clamped the drag to it. `minWidth` and\n`minHeight` default to the 80×54 floor a window can still be worked at;\nthe maxes are unbounded. A min equal to its max locks that axis —\n`min-height=\"67\" max-height=\"67\"` on a strip that scrolls sideways and\nnever grows taller, so the grow box changes the width alone.\n\nBounds the gesture only: an authored `width`/`height` outside the rect\nrenders as declared, and the first grow-box move brings it inside. The\nclamp runs after the drag's lattice snap, so a bound lands exactly the\nway an authored size does, even off the lattice (an odd height at 2×);\nwhere a min and max cross, the max wins, so a window held under the\nfloor stays put instead of jumping to it.",
+              "value": { "type": "number | null | undefined" }
+            },
+            {
+              "name": "min-height",
+              "description": "See minWidth. Default 54.",
+              "value": { "type": "number | null | undefined" }
+            },
+            {
+              "name": "max-width",
+              "description": "See minWidth. Unbounded by default.",
+              "value": { "type": "number | null | undefined" }
+            },
+            {
+              "name": "max-height",
+              "description": "See minWidth. Unbounded by default.",
+              "value": { "type": "number | null | undefined" }
+            },
             {
               "name": "flush",
               "description": "Remove the default 12px body padding. Under `scrollbars` the body has\nnone to remove, so the flag reaches the built-in scroll area instead\nand drops its viewport's 8px inset: content runs to the frame and the\nrails, and the (0,0) of placed children is the content region's corner.",
@@ -3381,9 +3401,29 @@
               },
               {
                 "name": "resizable",
-                "description": "Show a grow box at the bottom-right corner for resizing.",
+                "description": "Show a grow box at the bottom-right corner for resizing. The drag is\nbounded per axis by the sizeRect below.",
                 "type": "boolean"
               },
+              {
+                "name": "minWidth",
+                "description": "The sizeRect: the range of sizes the grow box can drag the window to,\nper axis, in whole system px — GrowWindow's, where the app stated the\nrectangle and the Window Manager clamped the drag to it. `minWidth` and\n`minHeight` default to the 80×54 floor a window can still be worked at;\nthe maxes are unbounded. A min equal to its max locks that axis —\n`min-height=\"67\" max-height=\"67\"` on a strip that scrolls sideways and\nnever grows taller, so the grow box changes the width alone.\n\nBounds the gesture only: an authored `width`/`height` outside the rect\nrenders as declared, and the first grow-box move brings it inside. The\nclamp runs after the drag's lattice snap, so a bound lands exactly the\nway an authored size does, even off the lattice (an odd height at 2×);\nwhere a min and max cross, the max wins, so a window held under the\nfloor stays put instead of jumping to it.",
+                "type": "number | null | undefined"
+              },
+              {
+                "name": "minHeight",
+                "description": "See minWidth. Default 54.",
+                "type": "number | null | undefined"
+              },
+              {
+                "name": "maxWidth",
+                "description": "See minWidth. Unbounded by default.",
+                "type": "number | null | undefined"
+              },
+              {
+                "name": "maxHeight",
+                "description": "See minWidth. Unbounded by default.",
+                "type": "number | null | undefined"
+              },
               {
                 "name": "flush",
                 "description": "Remove the default 12px body padding. Under `scrollbars` the body has\nnone to remove, so the flag reaches the built-in scroll area instead\nand drops its viewport's 8px inset: content runs to the frame and the\nrails, and the (0,0) of placed children is the content region's corner.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vintage-frames",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "description": "Lit web components that emulate the look and feel of classic Mac OS System 7",
   "type": "module",
   "license": "MIT",