@usableapp/cardds 0.7.78 → 0.7.80

package/dist/sheets/SheetStack.d.ts

@@ -21,7 +21,7 @@ export interface SheetStackProps extends ComponentProps<'div'> {
     closed?: boolean;
     /** how an OPEN sheet meets the top bar of a closed stack in a `Screen fill`: `under` (default) stops under the bar · `flood` rises over it and fills the WHOLE screen (from the safe-top line down), the bar covered and hidden while a sheet is open. Only for a `closed` tap stack (warns once otherwise). Nothing resizes: the bar is a layer under the sheets */
     rise?: 'under' | 'flood';
-    /** what the base shows in a closed stack's headroom, behind the sheets, laid out against the peeks (a picture, a greeting) */
+    /** what the base shows in a closed stack's headroom, behind the sheets, laid out against the peeks (a picture, a greeting). A room too short for it keeps the upper thing whole and scrolls: the rest lies under the heads until the member scrolls up to it */
     base?: ReactNode;
 }
 /**

package/dist/sheets/SheetStack.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Children, cloneElement, isValidElement, useEffect, useLayoutEffect, useRef, useState } from 'react';
-import { useControlled, warnOnce } from '../state.js';
+import { useControlled, warnOnce, watchSize } from '../state.js';
 import { cx } from '../cx.js';
 import { Card } from '../cards/Card.js';
 import { StackSheet } from './StackSheet.js';
@@ -25,6 +25,19 @@ function measureRests(stack) {
     };
 }
 const SLOP = 8; // px a pointer may travel and still be a tap
+/* the base's room either holds what stands in it or is too short for it (`is-long`). The CSS lays both out the same way, from the
+   room's top once there is no room to spare, so the measure does not feed back; the class only says there is something to scroll. */
+function StackBase({ children }) {
+    const ref = useRef(null);
+    const [long, setLong] = useState(false);
+    useLayoutEffect(() => {
+        const box = ref.current;
+        if (!box)
+            return;
+        return watchSize([box, ...box.children], () => setLong(box.scrollHeight - box.clientHeight > 1));
+    });
+    return _jsx("div", { ref: ref, className: cx('sheet-stack__base', long && 'is-long'), children: children });
+}
 /* one wrapper around a sheet is fine (a host's own box). The props land on the Card or StackSheet inside it, so the card renders them. */
 function stamp(child, place) {
     if (SHEET.has(child.type))
@@ -163,5 +176,5 @@ export function SheetStack({ mode = 'tap', open, defaultOpen = null, onOpenChang
         };
         return stamp(child, place);
     }) : items;
-    return (_jsxs("div", { className: cx('sheet-stack', mode !== 'static' && `sheet-stack--${mode}`, fanned && 'sheet-stack--fanned', closed && 'sheet-stack--closed', flood && 'sheet-stack--flood', className), ...rest, ref: setRef, onClickCapture: clickCapture, onPointerDownCapture: pointerDownCapture, children: [stamped, base != null && _jsx("div", { className: "sheet-stack__base", children: base })] }));
+    return (_jsxs("div", { className: cx('sheet-stack', mode !== 'static' && `sheet-stack--${mode}`, fanned && 'sheet-stack--fanned', closed && 'sheet-stack--closed', flood && 'sheet-stack--flood', className), ...rest, ref: setRef, onClickCapture: clickCapture, onPointerDownCapture: pointerDownCapture, children: [stamped, base != null && _jsx(StackBase, { children: base })] }));
 }

package/lib/mcp.mjs

@@ -1,13 +1,35 @@
 // lib/mcp.mjs — `npx cardds mcp`: the catalog (lib/catalog.mjs) as an MCP server over stdio, so an AI session asks instead of reading src/.
 // Newline-delimited JSON-RPC 2.0 written by hand: the package has no MCP SDK and takes none. stdout carries protocol messages ONLY.
 import { createInterface } from 'node:readline';
-import { readFileSync } from 'node:fs';
+import { readFileSync, readdirSync, statSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import * as catalog from './catalog.mjs';
 import { GUIDE } from './guide.mjs';
 
 const { version } = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'), 'utf8'));
+/* A server lives as long as its session — hours, across releases. What it serves must be the catalog as it is NOW (Lh 2026-10-10: a
+   session opened the day before did not know CardFeed): `keeper` asks `stamp` before every answer and loads again when it changed. */
+const SOURCES = ['src', 'css', '.design-sync/previews', 'docs', 'lib', 'scripts'];
+const newest = (path) => {
+  let st;
+  try { st = statSync(path); } catch { return 0; }
+  if (!st.isDirectory()) return st.mtimeMs;
+  return Math.max(0, ...readdirSync(path).map((name) => newest(join(path, name))));
+};
+/** what the catalog was made from: a live repo's sources (the newest change among them), or the package's own catalog file */
+export const stampOf = (root) => root ? Math.max(...SOURCES.map((dir) => newest(join(root, dir)))) : newest(join(dirname(fileURLToPath(import.meta.url)), '..', 'dist', 'catalog.json'));
+/** the catalog, loaded again whenever `stamp()` answers something new. A load that fails keeps the catalog it had (a source half-edited) and is tried again on the next ask */
+export function keeper(load, stamp) {
+  let cat, at;
+  return () => {
+    const now = stamp();
+    if (cat !== undefined && now === at) return cat;
+    try { cat = load(); at = now; } catch (e) { if (cat === undefined) throw e; }
+    return cat;
+  };
+}
+
 const str = (description) => ({ type: 'string', description });
 const bool = (description) => ({ type: 'boolean', description });
 
@@ -60,12 +82,12 @@ const fail = (id, code, message) => ({ jsonrpc: '2.0', id, error: { code, messag
 
 /** serve the catalog until the client closes stdin; `root` serves a live repo (rebuilt first) instead of the package's */
 export function serve({ root, input = process.stdin, output = process.stdout } = {}) {
-  let cat;
+  const current = keeper(() => catalog.load({ root }), () => stampOf(root));
   const text = (r) => typeof r === 'string' ? r : JSON.stringify(r);
 
   // the catalog, or nothing: listing the tools must not fail because it cannot be loaded (a call says why)
   function loaded() {
-    try { return (cat ??= catalog.load({ root })); } catch { return undefined; }
+    try { return current(); } catch { return undefined; }
   }
 
   function call(params) {
@@ -75,8 +97,7 @@ export function serve({ root, input = process.stdin, output = process.stdout } =
     const missing = tool.inputSchema.required?.find((k) => typeof args[k] !== 'string');
     if (missing) return { content: [{ type: 'text', text: `${tool.name}: "${missing}" is required (a string)` }], isError: true };
     try {
-      cat ??= catalog.load({ root });
-      const result = tool.run(cat, args);
+      const result = tool.run(current(), args);
       return { content: [{ type: 'text', text: text(result) }], ...(result?.error && { isError: true }) };
     } catch (e) { return { content: [{ type: 'text', text: `${tool.name}: ${e.message}` }], isError: true }; }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usableapp/cardds",
-  "version": "0.7.78",
+  "version": "0.7.80",
   "license": "UNLICENSED",
   "type": "module",
   "description": "card-first mobile design system, React-first: the components in src/ are thin wrappers over the CSS contract (css/*.css stays the only truth); gallery/ shows every story live (npm run dev), tests/ measures the geometry.",
@@ -13,6 +13,9 @@
     "build": "node scripts/build-icons.mjs && tsc -p tsconfig.json && node scripts/flatten-css.mjs && node scripts/build-catalog.mjs",
     "test": "playwright test",
     "validate:inbox": "node scripts/validate-inbox.mjs",
+    "release": "node scripts/publish.mjs",
+    "release:check": "node scripts/publish.mjs --check",
+    "ci": "node scripts/ci.mjs",
     "prepack": "npm run build",
     "knobs": "node scripts/knobs.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p gallery/tsconfig.json --noEmit",