vintage-frames 0.5.4 → 0.5.6

package/custom-elements.json

@@ -10756,7 +10756,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "`<vf-scroll-area>` — a container whose scrollbars look like System 7.\n\nWhite box with a 1px black frame, an inner scrolling viewport, and scroll\nrails the kit draws itself as shadow DOM (the shared `vfScrollRail` recipe):\nboxed arrow buttons at each end, a loose 1-bit dot-dither trough, and the\nclassic fixed 16px thumb. The native scrollbar is hidden, never the native\nscrolling — wheel, trackpad momentum, keyboard, touch and assistive-tech\nscrolling stay the platform's, and ScrollRailController keeps the\nrail in sync while driving the classic interactions (thumb drag, trough\npaging, arrow stepping with auto-repeat). Every engine renders the same\nrail — there is no Firefox fallback skin anymore.\n\nEach reserved scroll rail is a permanent placeholder: arrow buttons on an\nempty white channel sit in the gutter even when the content fits, the\ndither and thumb filling in only once that axis overflows (System 7 drew\nan active window's no-overflow bar as arrows on a bare channel; driven\nby ScrollStateController). Which rails are reserved is set by\naxis; when both are reserved the bottom-right corner joins them.\n\nSize the host (width/height) from the outside; the viewport fills it.",
+          "description": "`<vf-scroll-area>` — a container whose scrollbars look like System 7.\n\nWhite box with a 1px black frame, an inner scrolling viewport, and scroll\nrails the kit draws itself as shadow DOM (the shared `vfScrollRail` recipe):\nboxed arrow buttons at each end, a loose 1-bit dot-dither trough, and the\nclassic fixed 16px thumb. The native scrollbar is hidden, never the native\nscrolling — wheel, trackpad momentum, keyboard, touch and assistive-tech\nscrolling stay the platform's, and ScrollRailController keeps the\nrail in sync while driving the classic interactions (thumb drag, trough\npaging, arrow stepping with auto-repeat). Every engine renders the same\nrail — there is no Firefox fallback skin anymore.\n\nEach reserved scroll rail is a permanent placeholder: arrow buttons on an\nempty white channel sit in the gutter even when the content fits, the\ndither and thumb filling in only once that axis overflows (System 7 drew\nan active window's no-overflow bar as arrows on a bare channel; driven\nby ScrollStateController). Which rails are reserved is set by\naxis; when both are reserved the bottom-right corner joins them,\nand corner reserves that cell on a single-axis rail too — the\nrail stops 15px short of the frame, for a grow box to land in.\n\nSize the host (width/height) from the outside; the viewport fills it. The\nviewport insets its content 8px; flush drops that inset so content\nruns to the frame and the rails.",
           "name": "VfScrollArea",
           "cssProperties": [
             {
@@ -10807,6 +10807,28 @@
               "attribute": "axis",
               "reflects": true
             },
+            {
+              "kind": "field",
+              "name": "flush",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Drop the viewport's 8px inset: slotted content and the (0,0) of placed\nchildren sit at the frame's inner edge, one system px from the frame\nbox (the border-floor compensation stays — see the viewport rule).\n`vf-window[scrollbars]` forwards its own `flush` here.",
+              "attribute": "flush",
+              "reflects": true
+            },
+            {
+              "kind": "field",
+              "name": "corner",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Reserve the bottom-right corner cell on a single-axis rail: the rail\nstops 15px short of the frame and the viewport spans the rest, leaving\nthe 15×15 cell — with the two dividers a `both` rail's corner carries —\nfor a grow box to land in. A `both` rail always has the cell, so the\nflag changes nothing there. `vf-window[scrollbars resizable]` sets it.",
+              "attribute": "corner",
+              "reflects": true
+            },
             {
               "kind": "field",
               "name": "label",
@@ -10915,6 +10937,24 @@
               "description": "Which scroll rails to reserve as permanent placeholders: `vertical`\n(default), `horizontal`, or `both`. Each reserved rail shows an empty white\nchannel until its axis overflows; the unreserved axis still scrolls\nnatively (wheel, keyboard) but draws no rail.",
               "fieldName": "axis"
             },
+            {
+              "name": "flush",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Drop the viewport's 8px inset: slotted content and the (0,0) of placed\nchildren sit at the frame's inner edge, one system px from the frame\nbox (the border-floor compensation stays — see the viewport rule).\n`vf-window[scrollbars]` forwards its own `flush` here.",
+              "fieldName": "flush"
+            },
+            {
+              "name": "corner",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Reserve the bottom-right corner cell on a single-axis rail: the rail\nstops 15px short of the frame and the viewport spans the rest, leaving\nthe 15×15 cell — with the two dividers a `both` rail's corner carries —\nfor a grow box to land in. A `both` rail always has the cell, so the\nflag changes nothing there. `vf-window[scrollbars resizable]` sets it.",
+              "fieldName": "corner"
+            },
             {
               "name": "label",
               "type": {
@@ -17245,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",
@@ -17256,7 +17332,7 @@
                 "text": "boolean"
               },
               "default": "false",
-              "description": "Remove the default 12px body padding.",
+              "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.",
               "attribute": "flush",
               "reflects": true
             },
@@ -17266,7 +17342,7 @@
               "type": {
                 "text": "'vertical' | 'horizontal' | 'both' | undefined"
               },
-              "description": "Put System 7 scroll rails on the window edge — the classic document\nwindow. The body slot renders inside a built-in `vf-scroll-area` pulled\none system pixel under the frame on every side, so the rails repaint the\nborder lines and a `resizable` window's grow box lands in the corner\ncell. Values mirror `vf-scroll-area`'s `axis`; the `heading` names the\nscroll region; the viewport part is re-exported. Implies `flush` (the\nviewport carries its own padding). The slotted composition (SPEC §5\nvf-scroll-area) still works for windows that want an inset well instead.",
+              "description": "Put System 7 scroll rails on the window edge — the classic document\nwindow. The body slot renders inside a built-in `vf-scroll-area` pulled\none system pixel under the frame on every side, so the rails repaint the\nborder lines and a `resizable` window's grow box lands in the corner\ncell — reserved on a single-axis rail too (the area's `corner`), unless\na populated status strip holds the grow box, when the rail runs edge to\nedge onto the strip's rule. Values mirror `vf-scroll-area`'s `axis`; the\n`heading` names the scroll region; the viewport part is re-exported.\nThe body's own padding goes; the viewport keeps its 8px inset unless\n`flush`, which passes through. The slotted composition (SPEC §5\nvf-scroll-area) still works for windows that want an inset well instead.",
               "attribute": "scrollbars",
               "reflects": true
             },
@@ -17627,16 +17703,48 @@
                 "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": {
                 "text": "boolean"
               },
               "default": "false",
-              "description": "Remove the default 12px body padding.",
+              "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.",
               "fieldName": "flush"
             },
             {
@@ -17644,7 +17752,7 @@
               "type": {
                 "text": "'vertical' | 'horizontal' | 'both' | undefined"
               },
-              "description": "Put System 7 scroll rails on the window edge — the classic document\nwindow. The body slot renders inside a built-in `vf-scroll-area` pulled\none system pixel under the frame on every side, so the rails repaint the\nborder lines and a `resizable` window's grow box lands in the corner\ncell. Values mirror `vf-scroll-area`'s `axis`; the `heading` names the\nscroll region; the viewport part is re-exported. Implies `flush` (the\nviewport carries its own padding). The slotted composition (SPEC §5\nvf-scroll-area) still works for windows that want an inset well instead.",
+              "description": "Put System 7 scroll rails on the window edge — the classic document\nwindow. The body slot renders inside a built-in `vf-scroll-area` pulled\none system pixel under the frame on every side, so the rails repaint the\nborder lines and a `resizable` window's grow box lands in the corner\ncell — reserved on a single-axis rail too (the area's `corner`), unless\na populated status strip holds the grow box, when the rail runs edge to\nedge onto the strip's rule. Values mirror `vf-scroll-area`'s `axis`; the\n`heading` names the scroll region; the viewport part is re-exported.\nThe body's own padding goes; the viewport keeps its 8px inset unless\n`flush`, which passes through. The slotted composition (SPEC §5\nvf-scroll-area) still works for windows that want an inset well instead.",
               "fieldName": "scrollbars"
             },
             {

package/dist/components/vf-scroll-area.d.ts

@@ -18,9 +18,13 @@ declare const VfScrollArea_base: (new (...args: any[]) => import("../position.js
  * dither and thumb filling in only once that axis overflows (System 7 drew
  * an active window's no-overflow bar as arrows on a bare channel; driven
  * by {@link ScrollStateController}). Which rails are reserved is set by
- * {@link axis}; when both are reserved the bottom-right corner joins them.
+ * {@link axis}; when both are reserved the bottom-right corner joins them,
+ * and {@link corner} reserves that cell on a single-axis rail too — the
+ * rail stops 15px short of the frame, for a grow box to land in.
  *
- * Size the host (width/height) from the outside; the viewport fills it.
+ * Size the host (width/height) from the outside; the viewport fills it. The
+ * viewport insets its content 8px; {@link flush} drops that inset so content
+ * runs to the frame and the rails.
  *
  * @slot - Scrollable content.
  * @csspart viewport - The inner scrolling container.
@@ -39,6 +43,21 @@ export declare class VfScrollArea extends VfScrollArea_base {
      * natively (wheel, keyboard) but draws no rail.
      */
     axis: 'vertical' | 'horizontal' | 'both';
+    /**
+     * Drop the viewport's 8px inset: slotted content and the (0,0) of placed
+     * children sit at the frame's inner edge, one system px from the frame
+     * box (the border-floor compensation stays — see the viewport rule).
+     * `vf-window[scrollbars]` forwards its own `flush` here.
+     */
+    flush: boolean;
+    /**
+     * Reserve the bottom-right corner cell on a single-axis rail: the rail
+     * stops 15px short of the frame and the viewport spans the rest, leaving
+     * the 15×15 cell — with the two dividers a `both` rail's corner carries —
+     * for a grow box to land in. A `both` rail always has the cell, so the
+     * flag changes nothing there. `vf-window[scrollbars resizable]` sets it.
+     */
+    corner: boolean;
     /**
      * Accessible name for the scrolling viewport, applied as its `aria-label`
      * (an `aria-label` on the host would not reach into the shadow DOM). The

package/dist/components/vf-scroll-area.js

@@ -13,7 +13,7 @@ import { property as h, query as g, state as _ } from "lit/decorators.js";
 //#region src/components/vf-scroll-area.ts
 var v = class extends r(d) {
 	constructor(...e) {
-		super(...e), this.scale = new t(this), this.gridSnap = new s(this), this.axis = "vertical", this.label = "", this.scrollState = new c(this, () => this.viewport, () => this.content, (e) => {
+		super(...e), this.scale = new t(this), this.gridSnap = new s(this), this.axis = "vertical", this.flush = !1, this.corner = !1, this.label = "", this.scrollState = new c(this, () => this.viewport, () => this.content, (e) => {
 			this._scrollable = e.x || e.y;
 		}), this.rail = new l(this, {
 			getScroll: () => this.viewport,
@@ -46,11 +46,13 @@ var v = class extends r(d) {
       }
       :host(:not([axis])) .box,
       :host([axis='vertical']) .box,
-      :host([axis='both']) .box {
+      :host([axis='both']) .box,
+      :host([corner]) .box {
         grid-template-columns: 1fr auto;
       }
       :host([axis='horizontal']) .box,
-      :host([axis='both']) .box {
+      :host([axis='both']) .box,
+      :host([corner]) .box {
         grid-template-rows: 1fr auto;
       }
       .viewport {
@@ -73,6 +75,23 @@ var v = class extends r(d) {
           var(--vf-scale, 1) * 8px + mod(var(--vf-scale, 1) * 1px, 1px)
         );
       }
+      /* flush: the inset goes, the border-floor term stays — content and the
+         (0,0) of placed children sit at the frame's inner edge, exactly one
+         system px from the frame box at every scale. */
+      :host([flush]) .viewport {
+        padding: mod(var(--vf-scale, 1) * 1px, 1px);
+      }
+      /* A single-axis rail with a reserved corner: the viewport spans the
+         track the missing rail would have taken, up to the corner cell, so
+         the rail stops 15px short of the frame. (A both-axes rail has no
+         missing track — the flag is inert there.) */
+      :host([corner][axis='horizontal']) .viewport {
+        grid-column: 1 / 3;
+      }
+      :host([corner]:not([axis])) .viewport,
+      :host([corner][axis='vertical']) .viewport {
+        grid-row: 1 / 3;
+      }
       .vf-rail--vertical {
         grid-area: 1 / 2;
       }
@@ -100,7 +119,7 @@ var v = class extends r(d) {
 		];
 	}
 	render() {
-		let e = this.axis !== "horizontal", t = this.axis === "horizontal" || this.axis === "both";
+		let e = this.axis !== "horizontal", t = this.axis === "horizontal" || this.axis === "both", n = e && t || this.corner;
 		return p`
       <div class="box vf-snap">
         <div
@@ -114,11 +133,17 @@ var v = class extends r(d) {
         </div>
         ${e ? u(this.rail, "vertical") : m}
         ${t ? u(this.rail, "horizontal") : m}
-        ${e && t ? p`<div class="vf-rail-corner" aria-hidden="true"></div>` : m}
+        ${n ? p`<div class="vf-rail-corner" aria-hidden="true"></div>` : m}
       </div>
     `;
 	}
 };
-n([h({ reflect: !0 })], v.prototype, "axis", void 0), n([h()], v.prototype, "label", void 0), n([g(".viewport")], v.prototype, "viewport", void 0), n([g(".content")], v.prototype, "content", void 0), n([_()], v.prototype, "_scrollable", void 0), v = n([e("vf-scroll-area")], v);
+n([h({ reflect: !0 })], v.prototype, "axis", void 0), n([h({
+	type: Boolean,
+	reflect: !0
+})], v.prototype, "flush", void 0), n([h({
+	type: Boolean,
+	reflect: !0
+})], v.prototype, "corner", void 0), n([h()], v.prototype, "label", void 0), n([g(".viewport")], v.prototype, "viewport", void 0), n([g(".content")], v.prototype, "content", void 0), n([_()], v.prototype, "_scrollable", void 0), v = n([e("vf-scroll-area")], v);
 //#endregion
 export { v as VfScrollArea };

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

@@ -92,18 +92,52 @@ 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;
-    /** Remove the default 12px body padding. */
+    /**
+     * 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
+     * and drops its viewport's 8px inset: content runs to the frame and the
+     * rails, and the (0,0) of placed children is the content region's corner.
+     */
     flush: boolean;
     /**
      * Put System 7 scroll rails on the window edge — the classic document
      * window. The body slot renders inside a built-in `vf-scroll-area` pulled
      * one system pixel under the frame on every side, so the rails repaint the
      * border lines and a `resizable` window's grow box lands in the corner
-     * cell. Values mirror `vf-scroll-area`'s `axis`; the `heading` names the
-     * scroll region; the viewport part is re-exported. Implies `flush` (the
-     * viewport carries its own padding). The slotted composition (SPEC §5
+     * cell — reserved on a single-axis rail too (the area's `corner`), unless
+     * a populated status strip holds the grow box, when the rail runs edge to
+     * edge onto the strip's rule. Values mirror `vf-scroll-area`'s `axis`; the
+     * `heading` names the scroll region; the viewport part is re-exported.
+     * The body's own padding goes; the viewport keeps its 8px inset unless
+     * `flush`, which passes through. The slotted composition (SPEC §5
      * vf-scroll-area) still works for windows that want an inset well instead.
      */
     scrollbars?: 'vertical' | 'horizontal' | 'both';

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()),
@@ -201,7 +206,9 @@ var z = 80, B = 54, V = 24, H = 8, U = class extends E(c(N)) {
          frame on every side, so its own frame border repaints the window's
          border lines exactly (no doubled frame), the rails run edge to edge,
          and a resizable window's grow box (z-index 1) lands over the rail
-         corner cell. */
+         corner cell — which the render reserves on a single-axis rail too
+         (the area's corner flag), except when the status strip holds the
+         grow box instead. */
       .edge-scroll {
         width: calc(100% + var(--vf-scale, 1) * 2px);
         height: calc(100% + var(--vf-scale, 1) * 2px);
@@ -293,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)}"
@@ -348,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) {
@@ -380,6 +387,8 @@ var z = 80, B = 54, V = 24, H = 8, U = class extends E(c(N)) {
                 <vf-scroll-area
                   class="edge-scroll"
                   axis=${this.scrollbars}
+                  ?flush=${this.flush}
+                  ?corner=${this.resizable && !this._hasStatus}
                   label=${this.heading || I}
                   exportparts="viewport"
                 >
@@ -405,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/dist/styles/recipes/scroll-rail.js

@@ -150,11 +150,17 @@ var s = i(r["gray-25"]), c = s.width, l = s.height, u = s.rects, d = e(c, l, t(u
     width: calc(var(--vf-scale, 1) * 16px);
   }
 
-  /* The both-axes corner cell. It supplies the two interior dividers
+  /* The corner cell: the rails' own 15px in both dimensions, so it sizes its
+     grid track even when only one rail is there to size it (vf-scroll-area's
+     corner flag on a single-axis rail). It supplies the two interior dividers
      (against the vertical increment arrow above and the horizontal one
-     beside it) that those buttons leave to it; a resizable window's grow box
-     lands exactly over it. */
+     beside it) that those buttons leave to it — on a single-axis rail the
+     other divider continues the rail's line across the cell, the way
+     DrawGrowIcon drew it; a resizable window's grow box lands exactly over
+     it. */
   .vf-rail-corner {
+    width: calc(var(--vf-scale, 1) * 15px);
+    height: calc(var(--vf-scale, 1) * 15px);
     background: var(--vf-white, #fff);
     border-top: calc(var(--vf-scale, 1) * 1px) solid var(--vf-black, #000);
     border-left: calc(var(--vf-scale, 1) * 1px) solid var(--vf-black, #000);

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 body padding), `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).
@@ -217,10 +217,10 @@ The desktop-window shell: the classic document window (see DragThing screenshot)
   - Body: `padding: 12px` (0 if `flush` or `scrollbars`), and `overflow: hidden` — the window being a fixed box, content taller than it is clipped at the frame the way the classic content region was, rather than painting out over the desktop; `scrollbars` is how the user reaches the rest. Two deliberate exemptions: `[scrollbars]` restores `overflow: visible`, because the edge-rail composition below pulls the scroll area one system px *outside* the body on every side and clipping would shave exactly that overhang off (the scroll area does its own clipping); and a control's drop-open panel is not clipped — `vf-select`'s list is `position: fixed` off the control's rect precisely to escape clipping ancestors (§5 vf-select), and it still escapes, because nothing between it and the viewport establishes a containing block for fixed descendants (the grid-snap correction is a `position: relative` left/top offset, never a transform — see §7). A `vf-menu` panel is anchored `position: absolute` and *would* clip, but a menu bar belongs to the desktop, not inside a window body.
   - Grow box (if `resizable`): 15×15 at bottom-right corner, white bg, 1px black top/left borders, containing two overlapping small square outlines. Inactive: the cell and its borders stay, the nested squares go — System 7 drew a deactivated window's size box hollow, with its blanked scroll rails.
   - Status bar (`status` slot): the classic bottom readout strip ("40px x 40px") — a 1px black rule (`vfRule`'s `.vf-rule-top`) over a white interior, `--vf-status-bar-height` (15px) in all, the grow box's own height, so a `resizable` window's grow box sits flush in the strip's right end (its top/left borders take over the rule there; the strip reserves 21px of right padding under `resizable` so text clears the cell). Slotted content rides the body face's native 12px line (`--vf-line-height`), whole-pixel centered in the 14px interior, `padding-inline: 6px`, nowrap + clipped. Takes **no space** until the slot is populated (the dialog-footer pattern), and collapses again when it empties. Composes with `scrollbars`: the edge rails' bottom overhang lands its frame line exactly on the strip's rule, so the two never double up — though the grow box then sits in the strip rather than the rail corner cell.
-  - 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. Same caveats as the slotted composition (see vf-scroll-area §5), which remains supported for inset wells.
+  - 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 }`).
@@ -389,11 +389,11 @@ Classic list box.
 
 #### `vf-scroll-area` (`VfScrollArea`, vf-scroll-area.ts)
 A container whose scrollbars look like System 7.
-- **Attributes/props:** `axis: 'vertical' | 'horizontal' | 'both'` (default `'vertical'`, reflected) — which scroll rails to reserve as permanent placeholders (see "always-a-rail" below); `label: string` — accessible name for the viewport (`aria-label` on the viewport, since an `aria-label` on the host cannot reach into the shadow DOM). The viewport is a **Tab stop only while its content actually overflows** — the same state `ScrollStateController` measures for the rails; a fitting scroll area used to be a focusable stop with `role: generic` and no name, a dead Tab press. Whenever it is a stop it carries a role: `role="region"` when `label` names it (a named landmark), `role="group"` when not (an unnamed region is inert, so that role is reserved for the labelled case).
-- **Visual:** `display: block`; the snapped wrapper carries a real 1px black frame and a grid reserving each rail as its own edge column/row — `[viewport | vertical rail]` over `[horizontal rail | corner]` — with the white inner viewport padded `8px` plus the border-floor compensation (a `mod()` term restoring what engines floor off the fractional border-width, so slotted content and the (0,0) of placed children sit exactly 9 system px from the frame box at every scale). Consumer sets width/height on host. The rails are the drawn `vfScrollRail` subtree (§4 — the classic 16px cell counting the frame line: divider, 14px channel, 15px arrow cells, the fixed 16px thumb, the `tileRaster` dot-dither trough), rendered as later siblings of the viewport and synced to its native scrolling by `ScrollRailController`; the viewport carries the `vf-scroll` class, which hides the native bar without touching the native scrolling. When both rails are reserved, the corner cell joins them, supplying the interior dividers the adjacent arrow cells leave to it. Every engine renders the same rail; the old `::-webkit-scrollbar` skin, its `.vf-scroll-frame` overlay contortion (WebKit quantized native scrollbar rects to whole CSS px) and the Firefox `scrollbar-color` fallback are all retired.
+- **Attributes/props:** `axis: 'vertical' | 'horizontal' | 'both'` (default `'vertical'`, reflected) — which scroll rails to reserve as permanent placeholders (see "always-a-rail" below); `flush: boolean` (default false, reflected) — drops the viewport's 8px inset, keeping the border-floor term, so content and the (0,0) of placed children sit at the frame's inner edge; `corner: boolean` (default false, reflected) — reserves the bottom-right corner cell on a single-axis rail (the rail stops 15px short of the frame, the viewport spans the rest), for a grow box to land in; inert on `both`, which always has the cell; `label: string` — accessible name for the viewport (`aria-label` on the viewport, since an `aria-label` on the host cannot reach into the shadow DOM). The viewport is a **Tab stop only while its content actually overflows** — the same state `ScrollStateController` measures for the rails; a fitting scroll area used to be a focusable stop with `role: generic` and no name, a dead Tab press. Whenever it is a stop it carries a role: `role="region"` when `label` names it (a named landmark), `role="group"` when not (an unnamed region is inert, so that role is reserved for the labelled case).
+- **Visual:** `display: block`; the snapped wrapper carries a real 1px black frame and a grid reserving each rail as its own edge column/row — `[viewport | vertical rail]` over `[horizontal rail | corner]` — with the white inner viewport padded `8px` plus the border-floor compensation (a `mod()` term restoring what engines floor off the fractional border-width, so slotted content and the (0,0) of placed children sit exactly 9 system px from the frame box at every scale; `flush` keeps only the compensation, and they sit exactly 1). Consumer sets width/height on host. The rails are the drawn `vfScrollRail` subtree (§4 — the classic 16px cell counting the frame line: divider, 14px channel, 15px arrow cells, the fixed 16px thumb, the `tileRaster` dot-dither trough), rendered as later siblings of the viewport and synced to its native scrolling by `ScrollRailController`; the viewport carries the `vf-scroll` class, which hides the native bar without touching the native scrolling. When both rails are reserved, the corner cell joins them, supplying the interior dividers the adjacent arrow cells leave to it; `corner` reserves the same 15×15 cell beside a single rail, its other divider continuing the rail's line across the cell — DrawGrowIcon's form, for the grow box. Every engine renders the same rail; the old `::-webkit-scrollbar` skin, its `.vf-scroll-frame` overlay contortion (WebKit quantized native scrollbar rects to whole CSS px) and the Firefox `scrollbar-color` fallback are all retired.
 - **Always-a-rail behavior:** each *reserved* axis (per `axis`) renders its rail element as a permanent placeholder — arrow buttons on an empty white channel (dither off, no thumb; System 7 drew the arrows on any bar in an active window, and a scroller outside a window always counts as active) — until the content overflows that axis, when the dither and thumb fill in and the arrows go live (an idle axis's arrows are drawn but inert — the press guard in `ScrollRailController` skips them). `ScrollStateController` (`src/scroll-state.ts`) measures both axes and writes `data-overflow-x` / `data-overflow-y` (`"true"` / `"false"`) on the scroll element; the recipe keys the dither and thumb off those attributes. The unreserved axis still scrolls natively (wheel, keyboard) but draws no rail. Shared by vf-list and vf-text-area; a future `@container scroll-state(scrollable)` query could replace the JS for slotted-content components.
   - **Inactive-window blanking:** the HIG's non-frontmost window must not display interactive scroll UX, so the controller also finds the nearest `vf-window` up the composed tree (light-DOM ancestor for a slotted scroller, shadow ancestor for `vf-window[scrollbars]`'s own edge rails), watches its reflected `active` attribute, and toggles a presence-only `data-window-inactive` on the scroll element. While present, the recipe empties dither/thumb/arrows on BOTH axes regardless of overflow — the bare channel, arrows included (unlike the idle rail, which keeps them), exactly as System 7 blanked a deactivated window's bars (its List Manager/TextEdit deactivated in-window scrollbars too). No `vf-window` ancestor → the attribute never appears: dialogs have no inactive state and a bare scroll component always draws live. Like the overflow half, this signal could one day go declarative — a custom property cascaded under `vf-window:not([active])` gating the recipe via an `@container style()` query; the rails being ordinary DOM, that migration is a plain selector swap (see the FUTURE note in scroll-state.ts).
-- **Document-window (TeachText) composition:** to put the rails on a window's edge rather than inset in its body, slot the scroll area into a `vf-window[flush]` sized `calc(100% + 2px·scale)` with `margin: -1px·scale` — one system pixel under the window frame on every side. Its own frame border then repaints the window's border lines exactly (no doubled frame), and a resizable window's grow box lands exactly over the rail's corner cell, giving the classic System 7 document window. `vf-window[scrollbars]` renders exactly this composition from its own shadow tree, so the one-liner and the slotted form are geometrically identical; slot it yourself when the well should sit *inset* in the body instead (the installer's read-me well).
+- **Document-window (TeachText) composition:** to put the rails on a window's edge rather than inset in its body, slot the scroll area into a `vf-window[flush]` sized `calc(100% + 2px·scale)` with `margin: -1px·scale` — one system pixel under the window frame on every side. Its own frame border then repaints the window's border lines exactly (no doubled frame), and a resizable window's grow box lands exactly over the rail's corner cell, giving the classic System 7 document window. `vf-window[scrollbars]` renders exactly this composition from its own shadow tree (forwarding its `flush`, and `corner` for a resizable window without a status strip), so the one-liner and the slotted form are geometrically identical; slot it yourself when the well should sit *inset* in the body instead (the installer's read-me well).
 - **Slots:** default. **Parts:** `viewport`.
 
 #### `vf-fieldset` (`VfFieldset`, vf-fieldset.ts)

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

@@ -932,7 +932,7 @@
     },
     {
       "name": "vf-scroll-area",
-      "description": "`<vf-scroll-area>` — a container whose scrollbars look like System 7.\n\nWhite box with a 1px black frame, an inner scrolling viewport, and scroll\nrails the kit draws itself as shadow DOM (the shared `vfScrollRail` recipe):\nboxed arrow buttons at each end, a loose 1-bit dot-dither trough, and the\nclassic fixed 16px thumb. The native scrollbar is hidden, never the native\nscrolling — wheel, trackpad momentum, keyboard, touch and assistive-tech\nscrolling stay the platform's, and ScrollRailController keeps the\nrail in sync while driving the classic interactions (thumb drag, trough\npaging, arrow stepping with auto-repeat). Every engine renders the same\nrail — there is no Firefox fallback skin anymore.\n\nEach reserved scroll rail is a permanent placeholder: arrow buttons on an\nempty white channel sit in the gutter even when the content fits, the\ndither and thumb filling in only once that axis overflows (System 7 drew\nan active window's no-overflow bar as arrows on a bare channel; driven\nby ScrollStateController). Which rails are reserved is set by\naxis; when both are reserved the bottom-right corner joins them.\n\nSize the host (width/height) from the outside; the viewport fills it.\n---\n\n\n### **Slots:**\n - _default_ - Scrollable content.\n\n### **CSS Properties:**\n - **--vf-scrollbar-thumb** - scrollbar thumb/elevator (white) _(default: undefined)_\n- **--vf-scrollbar-track** - the scroll trough's base color under the dot-dither (white) _(default: undefined)_\n\n### **CSS Parts:**\n - **viewport** - The inner scrolling container.",
+      "description": "`<vf-scroll-area>` — a container whose scrollbars look like System 7.\n\nWhite box with a 1px black frame, an inner scrolling viewport, and scroll\nrails the kit draws itself as shadow DOM (the shared `vfScrollRail` recipe):\nboxed arrow buttons at each end, a loose 1-bit dot-dither trough, and the\nclassic fixed 16px thumb. The native scrollbar is hidden, never the native\nscrolling — wheel, trackpad momentum, keyboard, touch and assistive-tech\nscrolling stay the platform's, and ScrollRailController keeps the\nrail in sync while driving the classic interactions (thumb drag, trough\npaging, arrow stepping with auto-repeat). Every engine renders the same\nrail — there is no Firefox fallback skin anymore.\n\nEach reserved scroll rail is a permanent placeholder: arrow buttons on an\nempty white channel sit in the gutter even when the content fits, the\ndither and thumb filling in only once that axis overflows (System 7 drew\nan active window's no-overflow bar as arrows on a bare channel; driven\nby ScrollStateController). Which rails are reserved is set by\naxis; when both are reserved the bottom-right corner joins them,\nand corner reserves that cell on a single-axis rail too — the\nrail stops 15px short of the frame, for a grow box to land in.\n\nSize the host (width/height) from the outside; the viewport fills it. The\nviewport insets its content 8px; flush drops that inset so content\nruns to the frame and the rails.\n---\n\n\n### **Slots:**\n - _default_ - Scrollable content.\n\n### **CSS Properties:**\n - **--vf-scrollbar-thumb** - scrollbar thumb/elevator (white) _(default: undefined)_\n- **--vf-scrollbar-track** - the scroll trough's base color under the dot-dither (white) _(default: undefined)_\n\n### **CSS Parts:**\n - **viewport** - The inner scrolling container.",
       "attributes": [
         {
           "name": "axis",
@@ -943,6 +943,16 @@
             { "name": "both" }
           ]
         },
+        {
+          "name": "flush",
+          "description": "Drop the viewport's 8px inset: slotted content and the (0,0) of placed\nchildren sit at the frame's inner edge, one system px from the frame\nbox (the border-floor compensation stays — see the viewport rule).\n`vf-window[scrollbars]` forwards its own `flush` here.",
+          "values": []
+        },
+        {
+          "name": "corner",
+          "description": "Reserve the bottom-right corner cell on a single-axis rail: the rail\nstops 15px short of the frame and the viewport spans the rest, leaving\nthe 15×15 cell — with the two dividers a `both` rail's corner carries —\nfor a grow box to land in. A `both` rail always has the cell, so the\nflag changes nothing there. `vf-window[scrollbars resizable]` sets it.",
+          "values": []
+        },
         {
           "name": "label",
           "description": "Accessible name for the scrolling viewport, applied as its `aria-label`\n(an `aria-label` on the host would not reach into the shadow DOM). The\nviewport is keyboard-focusable while its content overflows, so without a\nname it is announced only as an anonymous scrollable group; setting\n`label` also promotes it to a named `role=\"region\"` landmark. While\n`label` is empty the viewport is a plain `group` when scrollable (an\nunnamed region is inert) and role-less when not.",
@@ -1351,17 +1361,37 @@
         },
         {
           "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": []
         },
         {
           "name": "flush",
-          "description": "Remove the default 12px body padding.",
+          "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.",
           "values": []
         },
         {
           "name": "scrollbars",
-          "description": "Put System 7 scroll rails on the window edge — the classic document\nwindow. The body slot renders inside a built-in `vf-scroll-area` pulled\none system pixel under the frame on every side, so the rails repaint the\nborder lines and a `resizable` window's grow box lands in the corner\ncell. Values mirror `vf-scroll-area`'s `axis`; the `heading` names the\nscroll region; the viewport part is re-exported. Implies `flush` (the\nviewport carries its own padding). The slotted composition (SPEC §5\nvf-scroll-area) still works for windows that want an inset well instead.",
+          "description": "Put System 7 scroll rails on the window edge — the classic document\nwindow. The body slot renders inside a built-in `vf-scroll-area` pulled\none system pixel under the frame on every side, so the rails repaint the\nborder lines and a `resizable` window's grow box lands in the corner\ncell — reserved on a single-axis rail too (the area's `corner`), unless\na populated status strip holds the grow box, when the rail runs edge to\nedge onto the strip's rule. Values mirror `vf-scroll-area`'s `axis`; the\n`heading` names the scroll region; the viewport part is re-exported.\nThe body's own padding goes; the viewport keeps its 8px inset unless\n`flush`, which passes through. The slotted composition (SPEC §5\nvf-scroll-area) still works for windows that want an inset well instead.",
           "values": [
             { "name": "vertical" },
             { "name": "horizontal" },

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.4",
+  "version": "0.5.6",
   "description-markup": "markdown",
   "contributions": {
     "html": {
@@ -2239,7 +2239,7 @@
         },
         {
           "name": "vf-scroll-area",
-          "description": "`<vf-scroll-area>` — a container whose scrollbars look like System 7.\n\nWhite box with a 1px black frame, an inner scrolling viewport, and scroll\nrails the kit draws itself as shadow DOM (the shared `vfScrollRail` recipe):\nboxed arrow buttons at each end, a loose 1-bit dot-dither trough, and the\nclassic fixed 16px thumb. The native scrollbar is hidden, never the native\nscrolling — wheel, trackpad momentum, keyboard, touch and assistive-tech\nscrolling stay the platform's, and ScrollRailController keeps the\nrail in sync while driving the classic interactions (thumb drag, trough\npaging, arrow stepping with auto-repeat). Every engine renders the same\nrail — there is no Firefox fallback skin anymore.\n\nEach reserved scroll rail is a permanent placeholder: arrow buttons on an\nempty white channel sit in the gutter even when the content fits, the\ndither and thumb filling in only once that axis overflows (System 7 drew\nan active window's no-overflow bar as arrows on a bare channel; driven\nby ScrollStateController). Which rails are reserved is set by\naxis; when both are reserved the bottom-right corner joins them.\n\nSize the host (width/height) from the outside; the viewport fills it.\n---\n\n\n### **Slots:**\n - _default_ - Scrollable content.\n\n### **CSS Properties:**\n - **--vf-scrollbar-thumb** - scrollbar thumb/elevator (white) _(default: undefined)_\n- **--vf-scrollbar-track** - the scroll trough's base color under the dot-dither (white) _(default: undefined)_\n\n### **CSS Parts:**\n - **viewport** - The inner scrolling container.",
+          "description": "`<vf-scroll-area>` — a container whose scrollbars look like System 7.\n\nWhite box with a 1px black frame, an inner scrolling viewport, and scroll\nrails the kit draws itself as shadow DOM (the shared `vfScrollRail` recipe):\nboxed arrow buttons at each end, a loose 1-bit dot-dither trough, and the\nclassic fixed 16px thumb. The native scrollbar is hidden, never the native\nscrolling — wheel, trackpad momentum, keyboard, touch and assistive-tech\nscrolling stay the platform's, and ScrollRailController keeps the\nrail in sync while driving the classic interactions (thumb drag, trough\npaging, arrow stepping with auto-repeat). Every engine renders the same\nrail — there is no Firefox fallback skin anymore.\n\nEach reserved scroll rail is a permanent placeholder: arrow buttons on an\nempty white channel sit in the gutter even when the content fits, the\ndither and thumb filling in only once that axis overflows (System 7 drew\nan active window's no-overflow bar as arrows on a bare channel; driven\nby ScrollStateController). Which rails are reserved is set by\naxis; when both are reserved the bottom-right corner joins them,\nand corner reserves that cell on a single-axis rail too — the\nrail stops 15px short of the frame, for a grow box to land in.\n\nSize the host (width/height) from the outside; the viewport fills it. The\nviewport insets its content 8px; flush drops that inset so content\nruns to the frame and the rails.\n---\n\n\n### **Slots:**\n - _default_ - Scrollable content.\n\n### **CSS Properties:**\n - **--vf-scrollbar-thumb** - scrollbar thumb/elevator (white) _(default: undefined)_\n- **--vf-scrollbar-track** - the scroll trough's base color under the dot-dither (white) _(default: undefined)_\n\n### **CSS Parts:**\n - **viewport** - The inner scrolling container.",
           "doc-url": "",
           "attributes": [
             {
@@ -2250,6 +2250,16 @@
                 "default": "'vertical'"
               }
             },
+            {
+              "name": "flush",
+              "description": "Drop the viewport's 8px inset: slotted content and the (0,0) of placed\nchildren sit at the frame's inner edge, one system px from the frame\nbox (the border-floor compensation stays — see the viewport rule).\n`vf-window[scrollbars]` forwards its own `flush` here.",
+              "value": { "type": "boolean", "default": "false" }
+            },
+            {
+              "name": "corner",
+              "description": "Reserve the bottom-right corner cell on a single-axis rail: the rail\nstops 15px short of the frame and the viewport spans the rest, leaving\nthe 15×15 cell — with the two dividers a `both` rail's corner carries —\nfor a grow box to land in. A `both` rail always has the cell, so the\nflag changes nothing there. `vf-window[scrollbars resizable]` sets it.",
+              "value": { "type": "boolean", "default": "false" }
+            },
             {
               "name": "label",
               "description": "Accessible name for the scrolling viewport, applied as its `aria-label`\n(an `aria-label` on the host would not reach into the shadow DOM). The\nviewport is keyboard-focusable while its content overflows, so without a\nname it is announced only as an anonymous scrollable group; setting\n`label` also promotes it to a named `role=\"region\"` landmark. While\n`label` is empty the viewport is a plain `group` when scrollable (an\nunnamed region is inert) and role-less when not.",
@@ -2275,6 +2285,16 @@
                 "description": "Which scroll rails to reserve as permanent placeholders: `vertical`\n(default), `horizontal`, or `both`. Each reserved rail shows an empty white\nchannel until its axis overflows; the unreserved axis still scrolls\nnatively (wheel, keyboard) but draws no rail.",
                 "type": "'vertical' | 'horizontal' | 'both'"
               },
+              {
+                "name": "flush",
+                "description": "Drop the viewport's 8px inset: slotted content and the (0,0) of placed\nchildren sit at the frame's inner edge, one system px from the frame\nbox (the border-floor compensation stays — see the viewport rule).\n`vf-window[scrollbars]` forwards its own `flush` here.",
+                "type": "boolean"
+              },
+              {
+                "name": "corner",
+                "description": "Reserve the bottom-right corner cell on a single-axis rail: the rail\nstops 15px short of the frame and the viewport spans the rest, leaving\nthe 15×15 cell — with the two dividers a `both` rail's corner carries —\nfor a grow box to land in. A `both` rail always has the cell, so the\nflag changes nothing there. `vf-window[scrollbars resizable]` sets it.",
+                "type": "boolean"
+              },
               {
                 "name": "label",
                 "description": "Accessible name for the scrolling viewport, applied as its `aria-label`\n(an `aria-label` on the host would not reach into the shadow DOM). The\nviewport is keyboard-focusable while its content overflows, so without a\nname it is announced only as an anonymous scrollable group; setting\n`label` also promotes it to a named `role=\"region\"` landmark. While\n`label` is empty the viewport is a plain `group` when scrollable (an\nunnamed region is inert) and role-less when not.",
@@ -3270,17 +3290,37 @@
             },
             {
               "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.",
+              "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.",
               "value": { "type": "boolean", "default": "false" }
             },
             {
               "name": "scrollbars",
-              "description": "Put System 7 scroll rails on the window edge — the classic document\nwindow. The body slot renders inside a built-in `vf-scroll-area` pulled\none system pixel under the frame on every side, so the rails repaint the\nborder lines and a `resizable` window's grow box lands in the corner\ncell. Values mirror `vf-scroll-area`'s `axis`; the `heading` names the\nscroll region; the viewport part is re-exported. Implies `flush` (the\nviewport carries its own padding). The slotted composition (SPEC §5\nvf-scroll-area) still works for windows that want an inset well instead.",
+              "description": "Put System 7 scroll rails on the window edge — the classic document\nwindow. The body slot renders inside a built-in `vf-scroll-area` pulled\none system pixel under the frame on every side, so the rails repaint the\nborder lines and a `resizable` window's grow box lands in the corner\ncell — reserved on a single-axis rail too (the area's `corner`), unless\na populated status strip holds the grow box, when the rail runs edge to\nedge onto the strip's rule. Values mirror `vf-scroll-area`'s `axis`; the\n`heading` names the scroll region; the viewport part is re-exported.\nThe body's own padding goes; the viewport keeps its 8px inset unless\n`flush`, which passes through. The slotted composition (SPEC §5\nvf-scroll-area) still works for windows that want an inset well instead.",
               "value": {
                 "type": "'vertical' | 'horizontal' | 'both' | undefined"
               }
@@ -3361,17 +3401,37 @@
               },
               {
                 "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.",
+                "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.",
                 "type": "boolean"
               },
               {
                 "name": "scrollbars",
-                "description": "Put System 7 scroll rails on the window edge — the classic document\nwindow. The body slot renders inside a built-in `vf-scroll-area` pulled\none system pixel under the frame on every side, so the rails repaint the\nborder lines and a `resizable` window's grow box lands in the corner\ncell. Values mirror `vf-scroll-area`'s `axis`; the `heading` names the\nscroll region; the viewport part is re-exported. Implies `flush` (the\nviewport carries its own padding). The slotted composition (SPEC §5\nvf-scroll-area) still works for windows that want an inset well instead.",
+                "description": "Put System 7 scroll rails on the window edge — the classic document\nwindow. The body slot renders inside a built-in `vf-scroll-area` pulled\none system pixel under the frame on every side, so the rails repaint the\nborder lines and a `resizable` window's grow box lands in the corner\ncell — reserved on a single-axis rail too (the area's `corner`), unless\na populated status strip holds the grow box, when the rail runs edge to\nedge onto the strip's rule. Values mirror `vf-scroll-area`'s `axis`; the\n`heading` names the scroll region; the viewport part is re-exported.\nThe body's own padding goes; the viewport keeps its 8px inset unless\n`flush`, which passes through. The slotted composition (SPEC §5\nvf-scroll-area) still works for windows that want an inset well instead.",
                 "type": "'vertical' | 'horizontal' | 'both' | undefined"
               },
               {

package/package.json

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