@wenathlan/saddle 2.0.163 → 2.0.165

package/Dockerfile

@@ -1,4 +1,4 @@
-# saddle 2.0.162 — THE ENGINE CONTAINER FILE
+# saddle 2.0.165 — THE ENGINE CONTAINER FILE
 #
 # THE FAMILY CONTAINER DOCTRINE, THE SADDLE SHAPE: one versioned container
 # per engine, built like the site homes (argan, cadria) build theirs — a
@@ -16,9 +16,9 @@
 # THE THREE VARIANT PROFILES (the saddle-exclusive law: the only app of
 # the family that ships three) — select with the target flag:
 #
-#   docker build --target max       -t saddle:2.0.162 .
-#   docker build --target balanced  -t saddle:2.0.162-balanced .
-#   docker build --target lite      -t saddle:2.0.162-lite .
+#   docker build --target max       -t saddle:2.0.164 .
+#   docker build --target balanced  -t saddle:2.0.164-balanced .
+#   docker build --target lite      -t saddle:2.0.164-lite .
 #
 #   max       — the full profile catalog: the epyc 9965 class, 192 vcpu,
 #               384 threads, 1024 gib ram plan, the b200 gpu plan x8.
@@ -61,16 +61,41 @@
 # is the sandbox spec surface the console answers, never a host
 # distribution this container installs.
 #
+# THE OS DISTRIBUTION SEATS the saddle container carries (the osdistrib
+# law, saddle/containerarch.ts — the owner's sentence: "iniciar
+# distribuição do container saddle com por exemplo, grapheneos, omarchy
+# e outros sistemas dentro do saddle"): the container starts its
+# distribution catalog with the seven system seats the OSDISTRIBUTIONS
+# registry pins — grapheneos (a privacy and security hardened version of
+# android), omarchy (the arch linux-based distribution created by dhh),
+# vanilla os (based on ubuntu), maru os (firmware, not an application),
+# the v seat (the vlang platform the dependency catalog pins at 0.5.2,
+# never a guest distribution), the normal linux baseline and android —
+# every seat paired with the architecture legs the eleven-architecture
+# standard already carries (the mobile and firmware seats ride the arm64
+# legs, the desktop and baseline seats ride amd64 and arm64) and bound
+# to the max/balanced/lite engine plan trio the engineplans table owns.
+# The distribution matrix needs NO new build legs: the seats ride the
+# existing arch axis of this file (the amd64 and arm64 legs the pinned
+# base already resolves), so the publish lanes and the build matrix stay
+# untouched — the registry is the catalog the container lanes stamp and
+# the modality system reads (saddle/docs/osdistributions.md). The
+# 50gb-per-plan example the owner's law names stays PLAN CONFIG the
+# devthink plan logic stamps, never a container cap: the engines are
+# unlimited.
+#
 # THE ELEVEN-ARCHITECTURE PLATFORM STANDARD (the pr15 law): every
 # profile answers the eleven architecture seats the container standard
 # names — the CONTAINERARCHIDS of saddle/containerarch.ts (linux-x64,
 # darwin-arm64, windows-x64, linux-arm64, darwin-x64, windows-arm64,
 # linux-x64-musl, linux-riscv64, wasm32, darwin-arm64-v8,
-# windows-x64-gnu). The build legs follow the container-carried seats
-# the pinned node base honestly answers: the amd64 leg serves linux-x64
-# and linux-x64-musl, the arm64 leg serves linux-arm64, and the arm64/v8
-# leg serves the darwin-arm64-v8 abi seat (the arm64 legs ride qemu
-# emulation in the publish workflow). The linux-riscv64 seat the
+# windows-x64-gnu). The build legs follow the four base-carried legs
+# the pinned node base honestly answers (the go-style build index of
+# containerarch.ts): the amd64 leg serves linux-x64 and linux-x64-musl,
+# the arm64 leg serves linux-arm64 and the darwin-arm64-v8 abi seat
+# through its v8 variant, and the ppc64le and s390x legs ride the
+# go-style build index under qemu emulation in the publish workflow.
+# The linux-riscv64 seat the
 # containerarch standard carries on the bash:5 driver base answers the
 # honest coded absence on this node engine base (the pinned base ships
 # no riscv64 manifest), and the six target seats (the darwin and
@@ -118,7 +143,7 @@ ARG NODE_BASE_DIGEST
 # ===== stage: solbuild — the locked npm tree and the console spa =====
 FROM --platform=$BUILDPLATFORM ${NODE_BASE_TAG}@sha256:${NODE_BASE_DIGEST} AS solbuild
 
-ARG SADDLE_VERSION=2.0.162
+ARG SADDLE_VERSION=2.0.165
 
 WORKDIR /app
 
@@ -146,7 +171,7 @@ RUN npm run web:build:pages \
 # ===== stage: base — the hardened runtime floor every profile shares =====
 FROM ${NODE_BASE_TAG}@sha256:${NODE_BASE_DIGEST} AS base
 
-ARG SADDLE_VERSION=2.0.162
+ARG SADDLE_VERSION=2.0.165
 # the revision stamp the devthink container carries (DEVTHINK_REVISION
 # there): the publish legs pass the release sha at build time and the
 # revision label below declares the default-unknown local shape.
@@ -194,17 +219,19 @@ ENV NODE_ENV=production \
 
 # the arch-leg guard of the eleven-architecture standard: the pinned
 # node base resolves the platform of every leg buildx names, and this
-# echo layer stamps the honesty law into the build log — the two arches
-# the base carries answer their leg line (the amd64 leg serves the
-# linux-x64 and linux-x64-musl seats, the arm64 leg serves the
+# echo layer stamps the honesty law into the build log — the four
+# arches the base carries answer their leg line (the amd64 leg serves
+# the linux-x64 and linux-x64-musl seats, the arm64 leg serves the
 # linux-arm64 seat and the darwin-arm64-v8 abi seat through its v8
-# variant), the legacy builder (no platform axis) answers its documented
+# variant, the ppc64le and s390x legs ride the go-style build index of
+# the containerarch table under qemu emulation), the legacy builder
+# (no platform axis) answers its documented
 # note, and any other arch answers the coded refusal before the heavy
 # steps below could run (buildx itself fails such a leg at base
 # resolution first; the guard keeps the law loud on every builder).
 RUN case "${TARGETARCH:-}" in \
-      amd64|arm64) \
-        echo "arch leg ${TARGETARCH} of ${TARGETPLATFORM:-<unresolved>}: one of the two arches the pinned node base carries — the legs of the container-carried seats of the eleven-architecture standard (linux-x64 and linux-x64-musl on amd64, linux-arm64 and the darwin-arm64-v8 abi seat on arm64)" ;; \
+      amd64|arm64|ppc64le|s390x) \
+        echo "arch leg ${TARGETARCH} of ${TARGETPLATFORM:-<unresolved>}: one of the four arches the pinned node base carries — the build legs of the eleven-architecture standard (linux-x64 and linux-x64-musl on amd64, linux-arm64 and the darwin-arm64-v8 abi seat on arm64, the ppc64le and s390x go-style build-index legs under qemu emulation)" ;; \
       "") \
         echo "arch leg unresolved: the legacy builder carries no platform axis; buildkit answers TARGETARCH per leg" ;; \
       *) \

package/README.md

@@ -31,7 +31,7 @@ domain modules land beside the saddle domains:
 | `media.ts`, `render.ts`, `quantum.ts`, `tiers.ts` | media pipeline, GPU registry, quantum simulation, tier policy |
 | `security.ts`, `alternatives.ts` | hardening gates and the alternative-stack catalog |
 | `index.html`, `App.tsx`, `sol/` | the single SPA shell and the Sol theme (one tsx app with one stylesheet per theme) |
-| `server.ts`, `sandbox.ts` | the zero-dependency self-hosted API of the 2.0.163 grand-merge envelope (`node server.ts`; the api answers its version at `/api/v1/health`) and the browser-pure engine port |
+| `server.ts`, `sandbox.ts` | the zero-dependency self-hosted API of the 2.0.165 grand-merge envelope (`node server.ts`; the api answers its version at `/api/v1/health`) and the browser-pure engine port |
 | `vercel.json`, `netlify.toml` | the platform deploy adapters beside the surface they publish (the caddy ghost stays out of the tree) |
 | `specs/*` package exports | processors, gpus, cores, boards and the qemu/mttg/passage/docker envelopes |
 

package/cli.ts

@@ -14,7 +14,8 @@
 import { mkdtemp, readFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { argv } from "node:process";
+import { argv, stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
 import { eventbus } from "./foundation.ts";
 import { localmemory, localstorage } from "./virtual.ts";
 import { engine, inprocess, scheduler } from "./execution.ts";
@@ -44,7 +45,8 @@ import {
 export async function main(args = argv.slice(2)) {
   const command = args[0] ?? "help";
   /* Help stays short and lists only stable local commands. */
-  if (["help", "--help", "-h"].includes(command)) { console.log("saddle <command>\n\ncommands\n  help\n  modes\n  plan [qemu|docker|toml]\n  vm [qemu|docker|toml]\n  vmlint\n  gpus\n  runexample\n  script <run|background|status|docker|compile> [file|runid]\n  mcp"); return; }
+  if (["help", "--help", "-h"].includes(command)) { console.log("saddle <command>\n\ncommands\n  help\n  chat\n  modes\n  plan [qemu|docker|toml]\n  vm [qemu|docker|toml]\n  vmlint\n  gpus\n  runexample\n  script <run|background|status|docker|compile> [file|runid]\n  mcp"); return; }
+  if (command === "chat") { await renderchat(); return; }
   if (command === "modes") { console.log(JSON.stringify(modecatalog(), null, 2)); return; }
   if (command === "plan") { await renderplan(args[1]); return; }
   /* The vm/vmlint/gpus triad makes the nominal npm aliases (vm:create, */
@@ -271,4 +273,99 @@ async function renderscript(subcommand = "help", target = "") {
   }
 }
 
+/* ════════════════════════════════════════════════════════════════════ */
+/* Section 4: the chat console — the pr13 creation workspace seat: the */
+/* same windows 11 chat console the family clibin seats render, with   */
+/* the same tokens, the same titlebar and the same dpi ladder (native  */
+/* detection, 1x / 1.5x / 2x / 3x, never xdpi — the difference from    */
+/* the web / desktop surface is only the responsiveness).              */
+/* ════════════════════════════════════════════════════════════════════ */
+
+/** the chat accent of the prompt and the titlebar name (ansi 117 — the family accent #a3d7e6). */
+const CHATACCENT = "\x1b[38;5;117m" as const;
+/** the focus ink of the active top rule (ansi 75 — the family focus #4cc2ff). */
+const CHATFOCUS = "\x1b[38;5;75m" as const;
+/** the hover red of the unknown-command rows (ansi 203 — rgb(232, 17, 35)). */
+const CHATHOVER = "\x1b[38;5;203m" as const;
+/** the dim ink of the description rows (the minimal text law). */
+const CHATINK = "\x1b[2m" as const;
+/** the reset token that closes every colored run. */
+const CHATRESET = "\x1b[0m" as const;
+/** the single glyph of the rules and the rails. */
+const CHATBAR = "─" as const;
+/** the engine ownership one-liner of the seat, quoted from the README. */
+const CHATENGINE = "storage-backed jobs, ninety sandbox modalities and portable runners — the master engine of virtualization (README)" as const;
+/** the scale ladder the native detection resolves (the automatic scaling law). */
+const CHATSCALESTEPS = [1, 1.5, 2, 3] as const;
+
+/** the dpi frame the chat chrome renders inside: the resolved scale seat, the terminal columns and the rail length the titlebar draws. */
+interface chatframe {
+  /** the scale seat of the ladder (1, 1.5, 2 or 3). */
+  scale: number;
+  /** the columns the terminal answers (windows terminal, conpty, xterm, tmux — every pty reports them). */
+  columns: number;
+  /** the titlebar rail length in cells (the pixel rail folded to the grid and clamped so the line never wraps). */
+  rail: number;
+}
+
+/** resolves the dpi frame natively, zero dependencies: the columns come from stdout (every windows and linux terminal answers them), the scale seat from the column ladder — the explicit SADDLE_DPI environment override wins first (the native scaling knob). */
+function chatdetectframe(): chatframe {
+  const columns = Number.isFinite(stdout.columns) && Number(stdout.columns) > 0 ? Number(stdout.columns) : 80;
+  const override = Number(process.env.SADDLE_DPI ?? "");
+  const scale =
+    Number.isFinite(override) && override > 0 && CHATSCALESTEPS.includes(override as (typeof CHATSCALESTEPS)[number])
+      ? override
+      : columns >= 200
+        ? 3
+        : columns >= 160
+          ? 2
+          : columns >= 120
+            ? 1.5
+            : 1;
+  const rail = Math.max(4, Math.min(Math.round(24 * scale), columns - "saddle".length - 16));
+  return { scale, columns, rail };
+}
+
+/** runs the chat console: the titlebar, the top rule, the ❯ prompt and the dispatch (help, version, dpi, engine, exit) — the same chat look the web / desktop surfaces carry, an eof on stdin closing the console the same way exit does. */
+async function renderchat(): Promise<void> {
+  const frame = chatdetectframe();
+  let seatversion = "0.0.0";
+  try {
+    seatversion = String((JSON.parse(await readFile(new URL("./package.json", import.meta.url), "utf8")) as { version?: string }).version ?? "0.0.0");
+  } catch {
+    /* the guarded best-effort read answers the zero literal the version row prints */
+  }
+  const rl = createInterface({ input: stdin, output: stdout });
+  let eof = false;
+  rl.on("close", () => { eof = true; });
+  const rule = CHATBAR.repeat(Math.max(3, Math.round(3 * frame.scale)));
+  console.log(`${CHATACCENT}┌ saddle ─ cli${CHATRESET}  ${CHATINK}${CHATBAR.repeat(frame.rail)} ─ ❐ ✕${CHATRESET}`);
+  console.log(`${CHATFOCUS}${rule} saddle ${rule}${CHATRESET}`);
+  console.log(`${CHATACCENT}saddle${CHATRESET} ${CHATINK}v${seatversion}${CHATRESET}`);
+  console.log(`${CHATINK}the saddle console — same design as web / desktop, only the DPI differs. type help.${CHATRESET}`);
+  rl.setPrompt(`${CHATACCENT}❯${CHATRESET} `);
+  rl.prompt();
+  for await (const raw of rl) {
+    const line = raw.trim();
+    const command = line.length > 0 ? line.split(/\s+/)[0]!.toLowerCase() : "";
+    if (command === "exit") rl.close();
+    else if (command === "help") {
+      console.log(`${CHATINK}commands${CHATRESET}`);
+      console.log(`  help      ${CHATINK}this list${CHATRESET}`);
+      console.log(`  version   ${CHATINK}the package version, read from package.json at runtime${CHATRESET}`);
+      console.log(`  dpi       ${CHATINK}the resolved dpi seat of this terminal (scale, columns, rail)${CHATRESET}`);
+      console.log(`  engine    ${CHATINK}the engine ownership one-liner of the app${CHATRESET}`);
+      console.log(`  exit      ${CHATINK}close the console${CHATRESET}`);
+    }
+    else if (command === "version") console.log(`${CHATACCENT}saddle${CHATRESET} ${seatversion}`);
+    else if (command === "dpi") console.log(`${CHATACCENT}saddle${CHATRESET} ${CHATINK}dpi seat ${frame.scale}x on ${frame.columns} columns — rail ${frame.rail} cells, ladder 1x / 1.5x / 2x / 3x${CHATRESET}`);
+    else if (command === "engine") console.log(`${CHATINK}${CHATENGINE}${CHATRESET}`);
+    else if (command.length > 0) console.log(`${CHATHOVER}✕${CHATRESET} ${CHATINK}unknown command: ${command} — type help${CHATRESET}`);
+    if (command === "exit") break;
+    /* the prompt is cosmetic chrome: a piped stdin that already reached eof skips it, the buffered lines still answer. */
+    if (!eof) rl.prompt();
+  }
+  console.log(`${CHATINK}saddle console closed.${CHATRESET}`);
+}
+
 if (import.meta.url === `file://${argv[1]}`) main().catch((error) => { console.error(error); process.exitCode = 1; });