@wenathlan/argan 2.0.151 → 2.0.153

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wenathlan/argan",
-  "version": "2.0.151",
+  "version": "2.0.153",
   "repository": {
     "type": "git",
     "url": "https://github.com/wenathlan/devthink"
@@ -27,7 +27,7 @@
     "ecmascript": "^5.0.0",
     "firefox": ">=0.8.0",
     "iojs": "^1.0.0",
-    "node": ">=26.12.1 <27",
+    "node": ">=26.13.0 <27",
     "npm": "^12.1.0",
     "pnpm": "^12.6.0",
     "teleport": ">=0.2.0",
@@ -38,7 +38,6 @@
   "files": [
     "README.md",
     "docs",
-    "site",
     "tests"
   ],
   "homepage": "https://github.com/wenathlan/devthink/tree/main/argan",
@@ -61,23 +60,40 @@
     "restore:entry": "node -e \"const{readFileSync}=require('node:fs');const{execSync}=require('node:child_process');const script=/script[^>]*App\\.tsx/;const triad=/family=Inter[\\s\\S]*Geist\\+Mono/;const face=(h)=>script.test(h)&&triad.test(h);if(face(readFileSync('index.html','utf8'))){console.log('index.html already rides the source face');process.exit(0)}if(!face(execSync('git show HEAD:./index.html',{encoding:'utf8'}))){console.error('refusing: HEAD index.html is not the canonical source face yet (script App.tsx + the font triad) - land the source-face fix first; nothing was touched');process.exit(1)}execSync('git checkout -- index.html',{stdio:'inherit'});console.log('index.html restored from HEAD (the source face)')\""
   },
   "dependencies": {
+    "@fluentui/react-icons": "^2.0.345",
+    "@fontsource-variable/bricolage-grotesque": "^5.3.0",
+    "@fontsource-variable/geist-mono": "^5.3.0",
+    "@fontsource-variable/inter": "^5.3.0",
+    "@fontsource-variable/jetbrains-mono": "^5.3.0",
+    "@fontsource-variable/outfit": "^5.3.0",
     "@hono/node-server": "^2.1.5",
+    "@libsql/client": "^0.18.0",
     "@prisma/adapter-libsql": "^7.10.1",
-    "hono": "^4.13.13",
+    "@prisma/client": "^7.10.1",
+    "@wenathlan/saddle": "^2.1.6",
+    "@wenathlan/vault": "^2.0.152",
+    "gsap": "^3.15.0",
+    "hono": "^4.13.16",
     "ink": "^7.1.1",
+    "lucide-react": "^1.66.0",
+    "motion": "^12.43.0",
+    "react": "^19.3.1",
     "react-devtools-core": "^8.0.0",
+    "react-dom": "^19.3.1",
+    "three": "^0.187.0",
+    "wouter": "^3.13.0",
     "z-ai-web-dev-sdk": "^0.0.18"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.6.3",
-    "@capacitor/android": "^8.5.3",
-    "@capacitor/cli": "^8.5.3",
-    "@capacitor/core": "^8.5.3",
-    "@capacitor/ios": "^8.5.3",
-    "@fluentui/react-icons": "^2.0.344",
+    "@biomejs/biome": "^2.6.4",
+    "@capacitor/android": "^8.6.0",
+    "@capacitor/cli": "^8.6.0",
+    "@capacitor/core": "^8.6.0",
+    "@capacitor/ios": "^8.6.0",
+    "@fluentui/react-icons": "^2.0.345",
     "@hookform/resolvers": "^5.9.2",
     "@libsql/client": "^0.18.0",
-    "@opencode-ai/sdk": "^1.19.4",
+    "@opencode-ai/sdk": "^1.19.5",
     "@prisma/client": "^7.10.1",
     "@radix-ui/react-accordion": "^1.3.1",
     "@radix-ui/react-alert-dialog": "^1.2.1",
@@ -110,41 +126,50 @@
     "@tailwindcss/vite": "^4.3.3",
     "@tsconfig/node26": "^26.0.1",
     "@types/better-sqlite3": "^9.6.0",
-    "@types/chrome": "^0.3.6",
+    "@types/chrome": "^0.3.7",
     "@types/express": "^5.0.6",
-    "@types/node": "^26.6.5",
+    "@types/google.maps": "^3.66.9",
+    "@types/node": "^26.6.6",
     "@types/react": "^19.3.0",
     "@types/react-dom": "^19.3.0",
+    "@types/three": "^0.187.0",
     "@vitejs/plugin-react": "^6.1.2",
     "add": "^2.0.9",
-    "autoprefixer": "^10.6.1",
-    "axios": "^1.20.0",
+    "autoprefixer": "^10.6.2",
+    "axios": "^1.21.0",
     "better-sqlite3": "^13.0.3",
     "bun-types": "^1.4.4",
+    "cheerio": "^1.2.0",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
     "drizzle-kit": "^0.31.11",
     "drizzle-orm": "^0.45.4",
     "embla-carousel-react": "^8.6.0",
+    "emittery": "^2.2.0",
     "esbuild": "^0.28.2",
     "express": "^5.3.0",
     "fast-check": "^4.10.2",
     "framer-motion": "^13.5.1",
+    "hono": "^4.13.16",
     "input-otp": "^1.5.0",
-    "lucide-react": "^1.61.0",
+    "jsdom": "26.1.0",
+    "lucide-react": "^1.66.0",
     "mysql2": "^3.24.6",
     "nanoid": "^6.0.2",
     "next-themes": "^0.4.6",
-    "pnpm": "^12.15.0",
-    "postcss": "^8.5.31",
+    "p-limit": "^7.3.3",
+    "p-retry": "^8.0.1",
+    "playwright": "^1.64.1",
+    "pnpm": "^12.16.1",
+    "postcss": "^8.5.32",
     "prettier": "^3.9.10",
     "prisma": "^7.10.1",
     "react": "^19.3.1",
     "react-day-picker": "^10.0.2",
     "react-dom": "^19.3.1",
     "react-hook-form": "^7.91.0",
-    "react-resizable-panels": "^4.15.0",
+    "react-resizable-panels": "^4.16.0",
     "recharts": "^3.10.1",
     "sonner": "^2.0.8",
     "streamdown": "^2.7.1",
@@ -157,6 +182,7 @@
     "typescript": "^7.0.2",
     "vaul": "^1.1.2",
     "vite": "^8.3.5",
+    "vite-plugin-manus-runtime": "^0.0.59",
     "vitest": "^5.0.5",
     "wouter": "^3.13.0",
     "yaml": "^2.9.1",
@@ -174,8 +200,11 @@
     "proxy-addr": "2.0.8",
     "body-parser": "^2.4.0",
     "fast-uri": "^3.1.9",
-    "follow-redirects": "^1.16.1",
+    "follow-redirects": "^1.16.2",
+    "minimatch": "^11.0.3",
+    "glob": "^14.0.3",
     "zod": "^4.6.7",
-    "undici": "^7.30.1"
+    "undici": "^7.30.1",
+    "shell-quote": "^1.11.0"
   }
 }

package/tests/design.test.ts

@@ -37,9 +37,11 @@ describe("design contract", () => {
     }
   });
 
-  it("carries the argan jade #34d8a8 as the one signal (mark story #14b98c)", () => {
-    // the jade token stands literal and the primary rides it — both stay pinned
-    expect(CSS).toMatch(/--arg-jade: #34d8a8/);
+  it("carries the white sun as the one signal with the jade story in the mark (#14b98c)", () => {
+    // the white sun answers the single-theme law: the jade rides the signal
+    // alias and the story survives in the drawn brand mark
+    expect(CSS).toMatch(/--color-signal: #ffffff/);
+    expect(CSS).toMatch(/--arg-jade: var\(--color-signal\)/);
     expect(CSS).toMatch(/--sol-primary: var\(--arg-jade\)/);
     expect(MARK).toMatch(/#14b98c/);
   });
@@ -50,14 +52,14 @@ describe("design contract", () => {
   });
 
   it("never ships an all-properties transition", () => {
-    expect(/transition:\s*all/.test(CSS), "transition: all is a reprovação").toBe(false);
+    expect(/transition:\s*all/.test(CSS), "transition: all is a rejection").toBe(false);
   });
 
   it("never enters an element from zero scale (the windows dtPopIntro bounce excepted)", () => {
     const sansPopIntro = CSS.replace(/@keyframes dtPopIntro \{[\s\S]*?\n\}/g, "");
     expect(
       /scale\(0\)/.test(sansPopIntro),
-      "scale(0) entries are a reprovação (the dtPopIntro bounce of the windows recipe excepted)",
+      "scale(0) entries are a rejection (the dtPopIntro bounce of the windows recipe excepted)",
     ).toBe(false);
   });
 
@@ -120,7 +122,7 @@ describe("design contract", () => {
   });
 
   it("carries the flow contract sources (the entry gate behind the home anchor, the shared state module)", () => {
-    const GATE = read("../Sol/widgets/HomeEntrygate.tsx");
+    const GATE = read("../Sol/wingets/HomeEntrygate.tsx");
     const STATE = read("../onboardingstate.ts");
     const HOME = read("../Sol/home/home.tsx");
     const ONBOARDING = read("../Sol/onboarding/onboarding.tsx");

package/tests/mimetypes.test.ts

@@ -0,0 +1,114 @@
+// # mimetypes.test — honest unit tests for the gateway media type catalog, runnable
+// with the vitest runner:
+//   pnpm test
+// The suite pins the owner law of wave 2-a: three thousand mimetypes on the internal
+// api surface (3217 rows, every family the gateway answers for), the canonical pins of
+// the extension lookup (.ts answers video/mp2t, .tsx answers application/typescript),
+// the one-row-per-extension collision law and the catalog accessor that serves the
+// catalog offline.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import { listMimetypes } from "../catalog.ts";
+import {
+  extensionsForType,
+  findMimeType,
+  MIMETYPES,
+  MIMETYPE_COUNT,
+  mimeFamilyOf,
+  mimeTypeForExtension,
+  mimetypesByFamily,
+} from "../mimetypes.ts";
+
+/** The families the law names (the type tree the catalog must cover). */
+const LAW_FAMILIES: readonly string[] = [
+  "text", "image", "audio", "video", "application", "font", "model", "chemical",
+  "message", "multipart",
+];
+
+describe("mimetype catalog scale (the three-thousand law)", () => {
+  it("answers 3217 media types — past the three thousand line", () => {
+    assert.equal(MIMETYPE_COUNT, 3217);
+    assert.ok(MIMETYPE_COUNT >= 3000, "the catalog must clear three thousand");
+  });
+
+  it("carries one row per media type", () => {
+    const seen = new Set<string>();
+    for (const row of MIMETYPES) {
+      assert.ok(!seen.has(row.type), `the type ${row.type} rides twice`);
+      seen.add(row.type);
+    }
+    assert.equal(seen.size, MIMETYPE_COUNT);
+  });
+
+  it("covers every family of the owner law", () => {
+    const families = new Set(MIMETYPES.map((row) => row.family as string));
+    for (const family of LAW_FAMILIES) {
+      assert.ok(families.has(family), `the catalog must cover ${family}`);
+    }
+    assert.equal(families.size, 10);
+  });
+
+  it("answers the family of every row from the type tree before the slash", () => {
+    for (const row of MIMETYPES) {
+      assert.equal(row.family, row.type.split("/")[0]);
+    }
+  });
+});
+
+describe("mimetype canonical pins (the extension lookup law)", () => {
+  it("answers .ts with video/mp2t and .tsx with application/typescript", () => {
+    assert.equal(mimeTypeForExtension("ts")?.type, "video/mp2t");
+    assert.equal(mimeTypeForExtension(".tsx")?.type, "application/typescript");
+    assert.equal(mimeTypeForExtension("TS")?.type, "video/mp2t");
+    assert.equal(mimeTypeForExtension(".TSX")?.type, "application/typescript");
+  });
+
+  it("answers the everyday extensions of the web family", () => {
+    assert.equal(mimeTypeForExtension("html")?.type, "text/html");
+    assert.equal(mimeTypeForExtension(".css")?.type, "text/css");
+    assert.equal(mimeTypeForExtension("js")?.type, "application/javascript");
+    assert.equal(mimeTypeForExtension("json")?.type, "application/json");
+    assert.equal(mimeTypeForExtension("svg")?.type, "image/svg+xml");
+    assert.equal(mimeTypeForExtension("md")?.type, "text/markdown");
+    assert.equal(mimeTypeForExtension("wasm")?.type, "application/wasm");
+  });
+
+  it("resolves types case-insensitively and answers unknowns with undefined", () => {
+    assert.equal(findMimeType("VIDEO/MP2T")?.family, "video");
+    assert.equal(findMimeType(" application/typescript ")?.extensions.includes("tsx"), true);
+    assert.equal(mimeFamilyOf("font/woff2"), "font");
+    assert.equal(findMimeType("video/mp3t"), undefined);
+    assert.equal(mimeTypeForExtension("nope"), undefined);
+    assert.equal(mimeTypeForExtension(""), undefined);
+  });
+
+  it("lists the extensions of one type and the rows of one family", () => {
+    assert.deepEqual(extensionsForType("video/mp2t"), ["ts"]);
+    assert.deepEqual(extensionsForType("font/woff"), ["woff"]);
+    assert.equal(extensionsForType("video/mp3t").length, 0);
+    assert.equal(mimetypesByFamily("font").length, 6);
+    assert.ok(mimetypesByFamily("text").every((row) => row.family === "text"));
+  });
+
+  it("keeps every extension on exactly one row (the collision law)", () => {
+    const claimed = new Map<string, string>();
+    for (const row of MIMETYPES) {
+      for (const extension of row.extensions) {
+        const owner = claimed.get(extension);
+        assert.ok(owner === undefined, `.${extension} rides both ${owner} and ${row.type}`);
+        claimed.set(extension, row.type);
+      }
+    }
+    assert.ok(claimed.size > 1500, "the catalog maps a dense extension set");
+    assert.equal(claimed.get("ts"), "video/mp2t");
+    assert.equal(claimed.get("tsx"), "application/typescript");
+  });
+});
+
+describe("mimetype catalog on the catalog surface", () => {
+  it("serves the catalog through the typed accessor offline (the registry seed)", async () => {
+    const rows = await listMimetypes();
+    assert.equal(rows.length, MIMETYPE_COUNT);
+    assert.ok(rows.some((row) => row.type === "video/mp2t"));
+  });
+});

package/tests/protocols.test.ts

@@ -0,0 +1,106 @@
+// # protocols.test — honest unit tests for the gateway protocol mesh, runnable with
+// the vitest runner:
+//   pnpm test
+// The suite pins the owner law of wave 2-a: more than one hundred protocols on the
+// internal api surface (144 tls-capable wires over the hundred line, 231 rows above
+// the two hundred line), the canonical schemes of the mesh, the family grouping, the
+// tone derivation and the catalog accessor that serves the mesh offline.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import { listProtocols } from "../catalog.ts";
+import {
+  findProtocol,
+  PROTOCOLS,
+  PROTOCOL_COUNT,
+  protocolGroups,
+  protocolsByGroup,
+  protocolSchemes,
+  protocolTone,
+  tlsCapableProtocols,
+} from "../protocols.ts";
+
+/** The schemes the owner law names (the transfer and application wires of the mesh). */
+const LAW_SCHEMES: readonly string[] = [
+  "https", "wss", "webtransport", "webcodecs", "webrtc", "webdav", "webdavs", "sftp",
+  "ftps", "smtp", "smtps", "imap", "imaps", "pop3", "pop3s", "dns", "doh", "dot",
+  "quic", "h3", "h2", "h2c", "spdy", "socks5", "socks5h", "tor", "i2p", "ipfs",
+  "hypercore", "gemini", "gopher", "ldap", "ldaps", "rdp", "vnc", "ssh", "telnet",
+  "mqtt", "mqtts", "amqp", "amqps", "stomp", "nats", "grpc", "grpcs", "capnproto",
+  "msgpack-rpc", "thrift", "xmlrpc", "jsonrpc", "soap", "graphql-ws", "sse", "longpoll",
+  "echo", "discard", "chargen", "daytime", "ntp", "snmp", "syslog", "tftp",
+];
+
+describe("protocol mesh scale (the hundred law)", () => {
+  it("answers 231 protocols — more than one hundred, above the two hundred line", () => {
+    assert.equal(PROTOCOL_COUNT, 231);
+    assert.ok(PROTOCOL_COUNT > 100, "the mesh must clear one hundred");
+    assert.ok(PROTOCOL_COUNT >= 200, "the mesh must clear the two hundred line");
+  });
+
+  it("carries 144 tls-capable wires — the https-grade count clears one hundred", () => {
+    const capable = tlsCapableProtocols();
+    assert.equal(capable.length, 144);
+    assert.ok(capable.length > 100, "the tls-capable count must clear one hundred");
+  });
+
+  it("registers every scheme of the owner law", () => {
+    const schemes = new Set(protocolSchemes());
+    for (const scheme of LAW_SCHEMES) {
+      assert.ok(schemes.has(scheme), `the mesh must register ${scheme}`);
+    }
+  });
+
+  it("answers one row per scheme with a name, port, spec, family and state", () => {
+    const seen = new Set<string>();
+    for (const row of PROTOCOLS) {
+      assert.ok(!seen.has(row.scheme), `the scheme ${row.scheme} rides twice`);
+      seen.add(row.scheme);
+      assert.ok(row.name.length > 0, `${row.scheme} needs a name`);
+      assert.ok(row.port.length > 0, `${row.scheme} needs a port answer`);
+      assert.ok(row.spec.length > 0, `${row.scheme} needs a spec`);
+      assert.ok(row.state.length > 0, `${row.scheme} needs a state`);
+    }
+    assert.equal(seen.size, PROTOCOL_COUNT);
+  });
+});
+
+describe("protocol mesh grouping and lookups", () => {
+  it("groups the mesh into the fifteen family keywords", () => {
+    const groups = protocolGroups();
+    assert.equal(groups.length, 15);
+    for (const group of groups) {
+      assert.ok(protocolsByGroup(group).length > 0, `the ${group} family carries rows`);
+    }
+  });
+
+  it("answers the dns family with the argan home transports", () => {
+    const dns = protocolsByGroup("dns");
+    assert.equal(dns.length, 12);
+    assert.ok(dns.every((row) => row.group === "dns"));
+    const doh = dns.find((row) => row.scheme === "doh");
+    assert.equal(doh?.spec, "RFC 8484");
+    assert.equal(doh?.state, "preferred");
+  });
+
+  it("resolves schemes case-insensitively and answers unknowns with undefined", () => {
+    assert.equal(findProtocol("WSS")?.name, "WebSocket Secure");
+    assert.equal(findProtocol(" https ")?.port, "443");
+    assert.equal(findProtocol("gopher")?.security, "cleartext");
+    assert.equal(findProtocol("telstar"), undefined);
+  });
+
+  it("derives the pane tone from the security posture", () => {
+    assert.equal(protocolTone(findProtocol("wss")!), "success");
+    assert.equal(protocolTone(findProtocol("imap")!), "info");
+    assert.equal(protocolTone(findProtocol("telnet")!), "default");
+    assert.equal(protocolTone(findProtocol("http")!), "warning");
+  });
+});
+
+describe("protocol mesh on the catalog surface", () => {
+  it("serves the mesh through the typed accessor offline (the registry seed)", async () => {
+    const rows = await listProtocols();
+    assert.equal(rows.length, PROTOCOL_COUNT);
+    assert.ok(rows.some((row) => row.scheme === "webtransport"));
+  });
+});

package/tests/sandboxmodality.test.ts

@@ -0,0 +1,84 @@
+// # sandboxmodality.test — the workload lane declaration of argan (wave
+// WL1): the mirrored rows answer the engine catalog byte for byte (the
+// lockstep pin — every lane, role, demand and honest today the engine
+// FAMILYLANES table carries for argan, compared through the library
+// bridge so the vendor can never drift in silence), every row names the
+// app slug, and the seat law answers the deploy's opt-in (absent or blank
+// answers the declared local default, "join" opts the lanes onto the
+// platform's join resolver — the nuclear modality law, and a named
+// modality id pins the seat for the platform's join to validate at
+// dispatch — this module never judges engine vocabulary). runnable with
+// vitest:
+//   pnpm vitest run tests/sandboxmodality.test.ts
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import { lanesof } from "@wenathlan/saddle/workloadlaw";
+import {
+  APPSLUG,
+  SANDBOXLANEENV,
+  WORKLOADLANES,
+  laneof,
+  lanesandbox,
+  lanesandboxfromenv,
+} from "../sandboxmodality.ts";
+
+describe("the workload lane mirror (the engine catalog lockstep)", () => {
+  it("answers the engine catalog rows for argan — the byte pin", () => {
+    const engine = lanesof("argan");
+    assert.equal(engine.length, WORKLOADLANES.length, "the mirror carries every argan lane");
+    for (let index = 0; index < engine.length; index += 1) {
+      const row = engine[index];
+      const mirror = WORKLOADLANES[index];
+      assert.equal(mirror.app, row.app);
+      assert.equal(mirror.lane, row.lane, `lane ${index} id drifts from the engine`);
+      assert.equal(mirror.role, row.role, `lane ${row.lane} role drifts from the engine`);
+      assert.deepEqual(mirror.demand, row.demand, `lane ${row.lane} demand drifts from the engine`);
+      assert.equal(mirror.today, row.today, `lane ${row.lane} today drifts from the engine`);
+    }
+  });
+
+  it("carries the app slug on every row and answers the lane lookup", () => {
+    for (const row of WORKLOADLANES) {
+      assert.equal(row.app, APPSLUG);
+    }
+    const first = laneof("dnssec-validate");
+    assert.ok(first !== undefined);
+    assert.equal(first.today, "app-lane");
+    assert.equal(laneof("no-such-lane"), undefined);
+  });
+});
+
+describe("the sandbox lane seat (the deploy decides)", () => {
+  it("answers the declared local default when the deploy carries no choice", () => {
+    const absent = lanesandbox(undefined);
+    assert.deepEqual(absent, { ok: true, seat: "local", sandboxed: false });
+    const blank = lanesandbox("   ");
+    assert.deepEqual(blank, { ok: true, seat: "local", sandboxed: false });
+    const explicit = lanesandbox("local");
+    assert.deepEqual(explicit, { ok: true, seat: "local", sandboxed: false });
+  });
+
+  it("opts the lanes onto the platform join when the deploy chooses join", () => {
+    const joined = lanesandbox("join");
+    assert.deepEqual(joined, { ok: true, seat: "join", sandboxed: true, pinned: false });
+    const padded = lanesandbox("  join  ");
+    assert.deepEqual(padded, { ok: true, seat: "join", sandboxed: true, pinned: false });
+  });
+
+  it("pins the named modality for the platform join to validate", () => {
+    const pinned = lanesandbox("runner-node");
+    assert.deepEqual(pinned, { ok: true, seat: "runner-node", sandboxed: true, pinned: true });
+    // the module never judges engine vocabulary: the platform's join
+    // validates the pinned id at dispatch, the mirror only names it
+    const unusual = lanesandbox("microvm-firecracker");
+    assert.deepEqual(unusual, { ok: true, seat: "microvm-firecracker", sandboxed: true, pinned: true });
+  });
+
+  it("reads the seat off the environment lookup the deploy pins", () => {
+    assert.equal(SANDBOXLANEENV, "ARGAN_SANDBOX_LANE");
+    const unset = lanesandboxfromenv(() => undefined);
+    assert.deepEqual(unset, { ok: true, seat: "local", sandboxed: false });
+    const set = lanesandboxfromenv((key) => (key === SANDBOXLANEENV ? "join" : undefined));
+    assert.deepEqual(set, { ok: true, seat: "join", sandboxed: true, pinned: false });
+  });
+});