anentrypoint-design 0.0.420 → 0.0.422

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anentrypoint-design",
-  "version": "0.0.420",
+  "version": "0.0.422",
   "description": "247420 design system SDK — webjsx + modified ripple-ui, single-file ESM bundle for reproducible use of the AnEntrypoint design.",
   "type": "module",
   "main": "./dist/247420.js",

package/src/kits/os/theme.css

@@ -415,7 +415,12 @@ html, body {
   .app-text-cursor { animation: app-cursor-blink 0.5s step-end infinite; }
   @keyframes app-cursor-blink { 50% { opacity: 0; } }
 }
-@media (max-width: 1023px) and (min-width: 768px) {
+/* (min-height: 501px): short-landscape windows (<501px tall) in this width
+ * band are on the mobile contract, not tablet — see the matching guard on
+ * the .wm-root tablet-inset rule below. Without the guard this block showed
+ * the side-rail and rail-offset the menubar/taskbar while the mobile band
+ * simultaneously tried to lay out rail-less full-screen windows. */
+@media (max-width: 1023px) and (min-width: 768px) and (min-height: 501px) {
     .os-side-rail { display: flex; }
     .ds-247420 .wm-root { left: calc(var(--os-rail-w) + env(safe-area-inset-left, 0px)); }
     .os-menubar { padding-left: calc(var(--os-rail-w) + env(safe-area-inset-left, 0px) + var(--space-2, 8px)); }
@@ -563,8 +568,16 @@ html, body {
 /* With bars overlaying the wm-root, a maximized window's 34px titlebar would
  * sit exactly under the 34px menubar (untappable) and its body under the
  * taskbar; keep maximized windows between the bars on desktop/tablet. The
- * mobile band re-asserts its own contract in the responsive layer below. */
-@media (min-width: 768px) {
+ * mobile band re-asserts its own contract in the responsive layer below.
+ * The (min-height: 501px) guard keeps this rule out of the short-landscape
+ * mobile band (768-1023 wide AND <500 tall): the mobile .wm-root already
+ * carries the bar-inset there, so this between-the-bars geometry used to
+ * DOUBLE-inset maximized windows — a restored wm-max window measured
+ * y=104/h=240 instead of y=52/h=344 at 782x448 (witnessed live on thebird
+ * 2026-07-29). Guarding here (same idiom as the tablet-band rules below)
+ * instead of overriding inside the mobile band keeps the !important
+ * ratchet flat — no new declaration was needed. */
+@media (min-width: 768px) and (min-height: 501px) {
   /* LOAD-BEARING !important: wm.css declares `.wm-win.wm-max{top:0!important;
    * height:100%!important}` (wm.css:137-143). Only another !important can beat
    * an !important, regardless of specificity. */
@@ -640,6 +653,12 @@ html.ds-247420 { touch-action: pan-x pan-y; overscroll-behavior: none; -webkit-t
   color: var(--os-fg);
   min-width: 280px;
   box-shadow: var(--shadow-overlay);
+  /* Uncapped, the switcher grew one row per open window with no bound —
+   * witnessed live at 27 windows on a 448px-tall viewport: the overlay
+   * measured y=-344 / h=1136, its top rows unreachable above the screen.
+   * Cap to the viewport between the bars and scroll the overflow. */
+  max-height: calc(100dvh - (2 * var(--os-bar-h, 34px)) - 24px);
+  overflow-y: auto;
 }
 .ds-247420 .wm-switcher-item {
   padding: var(--space-2) var(--space-2-75);
@@ -1488,6 +1507,11 @@ html.ds-247420 { touch-action: pan-x pan-y; overscroll-behavior: none; -webkit-t
     border-radius: 0;
     box-shadow: none;
   }
+  /* A maximized window on the mobile band is just the full-screen window the
+   * rule above already describes — the desktop/tablet `.wm-win.wm-max`
+   * between-the-bars rule is kept out of this band by its own
+   * (min-height: 501px) guard (see its comment above), so no override is
+   * needed here and the !important ratchet stays flat. */
   /* titlebar must host a 44px close button -> 44px bar (beats the 34px brand
    * clamp by later source order at equal specificity) */
   .ds-247420 .wm-bar {
@@ -1529,8 +1553,17 @@ html.ds-247420 { touch-action: pan-x pan-y; overscroll-behavior: none; -webkit-t
  * the scoped inset:0; re-asserted here at equal (0,2,0) specificity but later
  * source order, which is enough now that the earlier rule is also scoped.
  * `inset` alone carries the left offset — the separate `left` declaration it
- * used to be paired with was redundant with this shorthand. --- */
-@media (min-width: 768px) and (max-width: 1023px) {
+ * used to be paired with was redundant with this shorthand.
+ * The (min-height: 501px) guard excludes the short-landscape overlap band
+ * (768-1023 wide AND <500 tall): both this query and the mobile band's
+ * (max-height: 500px)+(orientation: landscape) match there, and this rule —
+ * later in source order — used to override the mobile bar-inset, dropping
+ * .wm-root to top:0 so full-screen windows covered the menubar and their
+ * close buttons landed under it occluded and untappable (witnessed live on
+ * thebird at 782x448: elementFromPoint on the chat close button hit
+ * .os-clock, menubar z 601 over window z 102). Short-landscape is the
+ * phone/mobile contract, not tablet. --- */
+@media (min-width: 768px) and (max-width: 1023px) and (min-height: 501px) {
   .ds-247420 .wm-root {
     inset: 0 0 0 var(--os-rail-w);
   }

package/src/shell.js

@@ -0,0 +1,173 @@
+// A real command interpreter for the terminal kit.
+//
+// The kit used to push '(stub) ran: <input>' into an array and render it -- the
+// word "stub" was visible to users, and nothing executed. This module is the
+// execution half: a virtual filesystem plus a command table, both synchronous
+// and dependency-free, so the terminal surface has something genuine to drive.
+//
+// Deliberately NOT a real OS. Commands operate on an in-memory tree; there is
+// no network, no eval, and no host access, so a demo page cannot be turned into
+// an exfiltration surface by typing into it. Unknown input reports a real
+// not-found error the way a shell does, rather than echoing success.
+
+const FS = {
+    'readme.md': 'the 247420 design system\n\nan editorial component library. run `ls` to look around,\n`help` for the command list.\n',
+    'colors_and_type.css': '/* the token bible: --acid, --ink, --paper, the --fs-* scale */\n',
+    src: {
+        'components.js': '// barrel over src/components/<group>.js\n',
+        'bootstrap.js': '// mountKit() -- every kit boots through here\n',
+        css: { 'app-shell.css': '/* @import barrel over app-shell/*.css */\n' },
+    },
+    ui_kits: {
+        'terminal/': null,
+        'dashboard/': null,
+        'file-browser/': null,
+    },
+};
+
+function nodeAt(path) {
+    let cur = FS;
+    for (const seg of path) {
+        if (!cur || typeof cur !== 'object') return undefined;
+        cur = cur[seg];
+    }
+    return cur;
+}
+
+const isDir = (n) => n && typeof n === 'object';
+
+// Resolve a user-typed path against cwd, honouring . and .. and a leading /.
+function resolvePath(cwd, raw) {
+    const parts = String(raw).split('/').filter(Boolean);
+    const out = String(raw).startsWith('/') ? [] : cwd.slice();
+    for (const p of parts) {
+        if (p === '.') continue;
+        if (p === '..') out.pop();
+        else out.push(p);
+    }
+    return out;
+}
+
+const promptPath = (cwd) => '~/' + cwd.join('/');
+
+// Each command returns an array of {kind, text} lines, matching the six line
+// kinds the kit's Line() renderer already knows: cmt, cmd, out, ok, warn, log.
+const COMMANDS = {
+    help(_args, ctx) {
+        const names = Object.keys(COMMANDS).sort();
+        return [
+            { kind: 'cmt', text: '# available commands' },
+            ...names.map((n) => ({ kind: 'out', text: n.padEnd(10) + COMMANDS[n].desc })),
+            { kind: 'out', text: '' },
+            { kind: 'out', text: 'up/down walks history, tab completes, ctrl+l or clear wipes the screen.' },
+        ];
+    },
+    ls(args, ctx) {
+        const target = args[0] ? resolvePath(ctx.cwd, args[0]) : ctx.cwd;
+        const node = nodeAt(target);
+        if (node === undefined) return [{ kind: 'warn', text: 'ls: ' + args[0] + ': no such file or directory' }];
+        if (!isDir(node)) return [{ kind: 'out', text: args[0] }];
+        const keys = Object.keys(node).sort();
+        if (!keys.length) return [{ kind: 'out', text: '(empty)' }];
+        return keys.map((k) => ({ kind: 'out', text: isDir(node[k]) ? k + '/' : k }));
+    },
+    cd(args, ctx) {
+        if (!args[0] || args[0] === '~') { ctx.cwd.length = 0; return []; }
+        const next = resolvePath(ctx.cwd, args[0]);
+        const node = nodeAt(next);
+        if (node === undefined) return [{ kind: 'warn', text: 'cd: ' + args[0] + ': no such file or directory' }];
+        if (!isDir(node)) return [{ kind: 'warn', text: 'cd: ' + args[0] + ': not a directory' }];
+        ctx.cwd.length = 0;
+        next.forEach((s) => ctx.cwd.push(s));
+        return [];
+    },
+    cat(args, ctx) {
+        if (!args[0]) return [{ kind: 'warn', text: 'cat: missing operand' }];
+        const node = nodeAt(resolvePath(ctx.cwd, args[0]));
+        if (node === undefined) return [{ kind: 'warn', text: 'cat: ' + args[0] + ': no such file or directory' }];
+        if (isDir(node)) return [{ kind: 'warn', text: 'cat: ' + args[0] + ': is a directory' }];
+        if (node === null) return [{ kind: 'out', text: '(binary or generated)' }];
+        return String(node).split('\n').map((text) => ({ kind: 'out', text }));
+    },
+    pwd(_args, ctx) { return [{ kind: 'out', text: promptPath(ctx.cwd) }]; },
+    echo(args) { return [{ kind: 'out', text: args.join(' ') }]; },
+    whoami() { return [{ kind: 'out', text: 'visitor@247420' }]; },
+    date() { return [{ kind: 'out', text: new Date().toString() }]; },
+    theme(args, ctx) {
+        const want = args[0];
+        if (want !== 'light' && want !== 'dark') {
+            return [{ kind: 'warn', text: 'theme: expected `light` or `dark`' }];
+        }
+        ctx.setTheme(want);
+        return [{ kind: 'ok', text: 'theme set to ' + want }];
+    },
+    clear(_args, ctx) { ctx.clear(); return []; },
+};
+
+COMMANDS.help.desc = 'list these commands';
+COMMANDS.ls.desc = 'list directory contents';
+COMMANDS.cd.desc = 'change directory';
+COMMANDS.cat.desc = 'print a file';
+COMMANDS.pwd.desc = 'print working directory';
+COMMANDS.echo.desc = 'write arguments to output';
+COMMANDS.whoami.desc = 'print the current user';
+COMMANDS.date.desc = 'print the current date';
+COMMANDS.theme.desc = 'switch light/dark';
+COMMANDS.clear.desc = 'clear the scrollback';
+
+// Split a command line into argv, honouring single and double quotes so
+// `echo "two words"` is one argument rather than two.
+export function tokenize(line) {
+    const out = [];
+    let cur = '';
+    let quote = null;
+    for (const ch of String(line)) {
+        if (quote) {
+            if (ch === quote) quote = null;
+            else cur += ch;
+        } else if (ch === '"' || ch === "'") {
+            quote = ch;
+        } else if (/\s/.test(ch)) {
+            if (cur) { out.push(cur); cur = ''; }
+        } else {
+            cur += ch;
+        }
+    }
+    if (cur) out.push(cur);
+    return out;
+}
+
+// Complete a partial word against command names (first token) or the current
+// directory's entries (any later token). Returns the completed line, or the
+// original when there is no unambiguous single match.
+export function complete(line, cwd) {
+    const argv = tokenize(line);
+    const trailing = /\s$/.test(line);
+    const head = trailing ? '' : (argv[argv.length - 1] || '');
+    const pool = (argv.length <= 1 && !trailing)
+        ? Object.keys(COMMANDS)
+        : Object.keys(nodeAt(cwd) || {});
+    const hits = pool.filter((k) => k.startsWith(head));
+    if (hits.length !== 1) return line;
+    const base = trailing ? argv : argv.slice(0, -1);
+    return [...base, hits[0]].join(' ');
+}
+
+export const commandNames = () => Object.keys(COMMANDS).sort();
+
+// Run one line. ctx carries { cwd, clear, setTheme } so commands can mutate the
+// session without this module reaching into the DOM itself.
+export function run(line, ctx) {
+    const argv = tokenize(line);
+    if (!argv.length) return [];
+    const [name, ...args] = argv;
+    const cmd = COMMANDS[name];
+    if (!cmd) {
+        return [{ kind: 'warn', text: name + ': command not found — try `help`' }];
+    }
+    try {
+        return cmd(args, ctx) || [];
+    } catch (err) {
+        return [{ kind: 'warn', text: name + ': ' + (err && err.message ? err.message : 'failed') }];
+    }
+}