@wenathlan/saddle 2.0.154 → 2.0.155

package/virtualgpu.ts

@@ -53,7 +53,7 @@
 import { execFileSync } from 'node:child_process';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
-import { MIGPROFILES } from './virtualmemory.js';
+import { MIGPROFILES } from './virtualmemory.ts';
 
 /** pci bdf (bus:device.function) validator: strict hex format only.
  *  blocks any shell metacharacter or path traversal. */

package/virtualization.ts

@@ -855,7 +855,7 @@ export const kvmcapnames: readonly string[] = [
 
 /** re-exports the gpu passthrough surface (vfio bind, rom dump, looking
  * glass, vgpu profiles) whose canonical home is virtualgpu.ts. */
-export * from './virtualgpu.js';
+export * from './virtualgpu.ts';
 
 /* ------------------------------------------------------------------ */
 /* context: checkpoint (criu planner, file snapshot, uffd, diff, live   */

package/workloadlaw.ts

@@ -0,0 +1,293 @@
+// # workloadlaw — the family workload lane catalog and the join law of the
+// engine (root layer, wave WL1). One row per heavy workload lane of every
+// official app of the family: the app that owns the lane, the lane's name,
+// the demand the lane puts on the sandbox (gpu, network, isolation depth,
+// boot budget) and where the lane runs today. The law this module answers
+// is the owner's nuclear modality law made executable for the whole
+// family: the workload never chooses a modality by name — the join
+// resolver reads the demand and answers the modality set that satisfies
+// it, so the person chooses none and the platform resolves the join of
+// all. Every lane row carries a demand and never a modality id: the
+// candidates are always computed from the registry of record
+// (modalityregistry.ts), so the answer can never drift from the catalog
+// and a modality that turns live tomorrow answers the same lane without
+// this file moving.
+//
+// The honest today fields: one row declares `today: "engine-lane"` when the
+// heavy pass already runs on a server-side engine surface of the family
+// (the os sandbox lane, the edge plane dispatcher, the app gateways the
+// deploys serve), and `today: "app-lane"` when the heavy pass still walks
+// inside the app surface (the seeded rehearsals, the browser fallbacks the
+// catalog laws keep naming). The report reads both truths beside the join
+// verdict — a lane that resolves dispatchable and still walks app-lane is
+// the next wave's work order, named honestly instead of hidden. The join
+// verdict itself answers from the registry alone: "dispatchable" when at
+// least one live modality satisfies the demand, "planned-only" when only
+// planned records do (the gpu lanes ride here today and say so), and
+// "unresolved" when the demand fits nothing — a calibration defect the
+// battery refuses.
+//
+// Pure data and pure functions: zero storage, zero node-only imports, the
+// browser-pure bundle keeps carrying it, exactly the registry law.
+
+import { type ModalityRecord, resolvejoin } from "./modalityregistry.ts";
+
+/** The demand one workload lane puts on the sandbox — the join vocabulary
+ * the resolver reads (never a modality name: the nuclear law). */
+export type WorkloadDemand = {
+  /** Whether the lane's pass needs a gpu path through the virtual drivers. */
+  gpu: boolean;
+  /** Whether the lane's pass needs a network path. */
+  network: boolean;
+  /** The isolation depth the lane demands at minimum. */
+  isolation: ModalityRecord["isolation"];
+  /** The boot budget the lane tolerates, in milliseconds (defaults to the
+   * cold ceiling of the ladder when absent). */
+  bootbudget?: number;
+};
+
+/** Where the heavy pass of the lane runs today — the honest truth the
+ * report reads beside the join verdict. */
+export type LaneToday = "engine-lane" | "app-lane";
+
+/** One workload lane of the family catalog: the app that owns the lane,
+ * the lane's stable id, the role sentence, the demand and the honest
+ * today. */
+export type WorkloadLane = {
+  /** The official app slug that owns the lane. */
+  app: string;
+  /** The lane id inside the app (kebab-case, unique per app). */
+  lane: string;
+  /** What the lane does, in one sentence. */
+  role: string;
+  /** The demand the lane puts on the sandbox. */
+  demand: WorkloadDemand;
+  /** Where the heavy pass runs today (the honest truth). */
+  today: LaneToday;
+};
+
+/** The join verdict of one lane: computed from the registry, never
+ * declared by hand. */
+export type LaneVerdict = "dispatchable" | "planned-only" | "unresolved";
+
+/** One answered join: the lane row, the verdict and the candidate records
+ * the resolver answered (best candidate first). */
+export type LaneJoin = {
+  /** The lane row the join answered. */
+  lane: WorkloadLane;
+  /** The honest verdict computed from the registry. */
+  verdict: LaneVerdict;
+  /** The modality records that satisfy the demand, best first. */
+  candidates: readonly ModalityRecord[];
+  /** How many candidates the registry already drives live. */
+  livecount: number;
+};
+
+/** The family workload lane catalog: the lanes of the eleven official
+ * apps, walked from the analysis waves (A1) that mapped every app's heavy
+ * passes. The rows carry demands and honest todays — never modality ids:
+ * the join computes the answer from the registry of record. */
+export const FAMILYLANES: readonly WorkloadLane[] = Object.freeze([
+  // the argan lanes: the dns engine's heavy passes
+  { app: "argan", lane: "dnssec-validate", role: "the dnssec chain validation walk: rrsig parsing, key tag checksums, validity windows and ds match rules over untrusted input", demand: { gpu: false, network: false, isolation: "process", bootbudget: 25 }, today: "app-lane" },
+  { app: "argan", lane: "zonefile-parse-diff", role: "the master file parse and the external-dns diff: tokenizer, normalization, creates/deletes/updates by group", demand: { gpu: false, network: false, isolation: "process", bootbudget: 25 }, today: "app-lane" },
+  { app: "argan", lane: "catalog-registry-serve", role: "the registry tables the catalog serves: mime types, protocols and seed rows over https and db, never the browser fallback", demand: { gpu: false, network: true, isolation: "process", bootbudget: 800 }, today: "app-lane" },
+  { app: "argan", lane: "label-store-seed", role: "the label manifest seed into the store: the upsert walk that protects translated rows, mirrored server-side", demand: { gpu: false, network: true, isolation: "process", bootbudget: 25 }, today: "app-lane" },
+  // the cadria lanes: the versawaze engine's generation passes
+  { app: "cadria", lane: "analyze-wav", role: "the audio analysis pipeline: decode, downmix, resample, stft and the spectrum, rhythm, tonality, timbre and structure fusion", demand: { gpu: false, network: false, isolation: "process", bootbudget: 800 }, today: "engine-lane" },
+  { app: "cadria", lane: "generate-image", role: "the image generation walk: palette, composition blocks, rhythm scatter, texture and motion into the deterministic project", demand: { gpu: false, network: false, isolation: "process", bootbudget: 25 }, today: "engine-lane" },
+  { app: "cadria", lane: "render-svg", role: "the svg render of the image project: draw command compilation and the byte-deterministic serialization", demand: { gpu: false, network: false, isolation: "process", bootbudget: 25 }, today: "engine-lane" },
+  { app: "cadria", lane: "decode-video", role: "the frame-accurate video decode lane: the container-namespace pass the codec walk rides, never the visitor decoder", demand: { gpu: false, network: false, isolation: "namespace", bootbudget: 800 }, today: "app-lane" },
+  { app: "cadria", lane: "compile-shader", role: "the shader program assembly: the fragment library, the deterministic manifest and the sha digest, no visitor gpu ever compiles", demand: { gpu: false, network: false, isolation: "process", bootbudget: 25 }, today: "engine-lane" },
+  // the cobaia lanes: the monetization surface's light walks
+  { app: "cobaia", lane: "plan-checkout", role: "the plan checkout surface: mrr plan rows, link validation and the billing webhook walk when it lands, secrets server-side", demand: { gpu: false, network: true, isolation: "process", bootbudget: 25 }, today: "app-lane" },
+  { app: "cobaia", lane: "ads-slot", role: "the honest ad slot lane: the reserved slots and the rotation decision the deploy answers before the render", demand: { gpu: false, network: true, isolation: "process", bootbudget: 25 }, today: "app-lane" },
+  { app: "cobaia", lane: "label-seed", role: "the label manifest seed of the monetization face: the store walk the sqlite vault carries", demand: { gpu: false, network: false, isolation: "process", bootbudget: 25 }, today: "app-lane" },
+  // the debonair lanes: the kathesis engine's audio walks
+  { app: "debonair", lane: "ingest-audio", role: "the ingest worker: the stream separation, the pcm downmix and the payload json the reconstruction reads", demand: { gpu: false, network: false, isolation: "process", bootbudget: 800 }, today: "engine-lane" },
+  { app: "debonair", lane: "render-track", role: "the render worker: the composed plan render, the mastering chain and the wav encode into the take store", demand: { gpu: false, network: false, isolation: "process", bootbudget: 800 }, today: "engine-lane" },
+  // the forge lanes: the execution clone's run walks
+  { app: "forge", lane: "binary-run", role: "the binary run lane: the runner the saddle engine answers for the fleet, the mode gate resolving through the join", demand: { gpu: false, network: true, isolation: "namespace", bootbudget: 800 }, today: "app-lane" },
+  { app: "forge", lane: "queue-priority", role: " the run queue walk: express, normal and batch ordering over the queue the lane serves", demand: { gpu: false, network: false, isolation: "process", bootbudget: 25 }, today: "app-lane" },
+  // the foundry lanes: the pipeline clone's graph walks
+  { app: "foundry", lane: "pipeline-graph", role: "the pipeline graph lane: provision, pull, run, collect and store — the plan walk the herd drives", demand: { gpu: false, network: false, isolation: "process", bootbudget: 25 }, today: "app-lane" },
+  { app: "foundry", lane: "image-artifact", role: "the image artifact lane: the format plans, the checksum seals and the shelf records the vault stores", demand: { gpu: false, network: false, isolation: "process", bootbudget: 25 }, today: "app-lane" },
+  // the getry lanes: the ai gateway's inference walks
+  { app: "getry", lane: "inference-route", role: "the inference route lane: the provider pool, the sse parse and the model masking over the upstream calls", demand: { gpu: false, network: true, isolation: "process", bootbudget: 800 }, today: "engine-lane" },
+  { app: "getry", lane: "stream-fallback", role: "the resilience runner: the verdict ladder, the backoff walk and the trail the retry lane keeps", demand: { gpu: false, network: true, isolation: "process", bootbudget: 25 }, today: "engine-lane" },
+  { app: "getry", lane: "thinking-ladder", role: "the seven-level reasoning ladder: the budget resolution the request injects before the upstream call", demand: { gpu: false, network: false, isolation: "process", bootbudget: 25 }, today: "engine-lane" },
+  { app: "getry", lane: "router-rotation", role: "the rotation lane: the weighted draw, the cooldown ledger and the session rows the store keeps", demand: { gpu: false, network: true, isolation: "process", bootbudget: 25 }, today: "engine-lane" },
+  // the saddle lanes: the engine's own dispatch surface
+  { app: "saddle", lane: "edge-dispatch", role: "the edge plane dispatch itself: the visitor guard, the lane resolution and the artifact commit through the vault seam", demand: { gpu: false, network: true, isolation: "process", bootbudget: 1500 }, today: "engine-lane" },
+  // the stealthhead lanes: the fps platform's simulation walks
+  { app: "stealthhead", lane: "match-simulate", role: "the authoritative match simulation: the fixed-step physics, the reconcile and rewind twin and the seeded spawns", demand: { gpu: false, network: true, isolation: "process", bootbudget: 25 }, today: "app-lane" },
+  { app: "stealthhead", lane: "rank-compute", role: "the ranking walk: the elo ladder, the season batch and the position assignment over the standing rows", demand: { gpu: false, network: true, isolation: "process", bootbudget: 800 }, today: "app-lane" },
+  { app: "stealthhead", lane: "world-bake", role: "the world pre-compilation: the map bake through the render engine — the gpu pass the planned modalities answer", demand: { gpu: true, network: true, isolation: "vm", bootbudget: 1500 }, today: "app-lane" },
+  { app: "stealthhead", lane: "ballistics-balance", role: "the armory balance sweep: falloff, shots-to-kill and ttk validation, offline and deterministic", demand: { gpu: false, network: false, isolation: "process", bootbudget: 25 }, today: "app-lane" },
+  // the vault lanes: the storage engine's object walks
+  { app: "vault", lane: "blob-ingest", role: "the object deposit lane: path and mime validation, the quota gate inside the write transaction and the detach walk", demand: { gpu: false, network: true, isolation: "process", bootbudget: 800 }, today: "engine-lane" },
+  { app: "vault", lane: "chunk-window", role: "the chunk window lane: the fixed slicing, the per-window digest and the brotli decision over the byte stream", demand: { gpu: false, network: false, isolation: "process", bootbudget: 800 }, today: "engine-lane" },
+  { app: "vault", lane: "digest-sha256", role: "the digest engine: the sha-256 master and chunk walks and the full re-verification the read path answers", demand: { gpu: false, network: false, isolation: "process", bootbudget: 25 }, today: "engine-lane" },
+  { app: "vault", lane: "ref-gc", role: "the reference gc lane: the soft-delete tombstones, the ref detach and the orphan sweep the store drives", demand: { gpu: false, network: true, isolation: "process", bootbudget: 800 }, today: "engine-lane" },
+  // the devthink lanes: the os envelope's command walks
+  { app: "devthink", lane: "chat-sandbox", role: "the chat sandbox lane: the session jail, the tool surface and the exec walks the engine dispatches server-side", demand: { gpu: false, network: true, isolation: "namespace", bootbudget: 1500 }, today: "engine-lane" },
+  { app: "devthink", lane: "llm-gateway", role: "the universal gateway pipeline: model resolution, auth, body building, retry and the streaming byte passthrough", demand: { gpu: false, network: true, isolation: "process", bootbudget: 800 }, today: "engine-lane" },
+  { app: "devthink", lane: "stream-parse", role: "the streaming parser: the tolerant sse walk, the payload normalization and the delta tracking over the live stream", demand: { gpu: false, network: true, isolation: "process", bootbudget: 25 }, today: "engine-lane" },
+  { app: "devthink", lane: "graph-run", role: "the graph runner: the deterministic stage walk, the retry ladder and the progress views the console draws", demand: { gpu: false, network: false, isolation: "process", bootbudget: 25 }, today: "engine-lane" },
+  { app: "devthink", lane: "mcp-serve", role: "the mcp registry lane: the tool catalog, the approval gates and the transports the server answers", demand: { gpu: false, network: true, isolation: "process", bootbudget: 800 }, today: "engine-lane" },
+]);
+
+/** The official app slugs the catalog covers — the lockstep vocabulary the
+ * ownership manifest of the os answers (every official app owns at least
+ * one workload lane here). */
+export const CATALOGAPPS: readonly string[] = Object.freeze([
+  "argan",
+  "cadria",
+  "cobaia",
+  "debonair",
+  "devthink",
+  "forge",
+  "foundry",
+  "getry",
+  "saddle",
+  "stealthhead",
+  "vault",
+]);
+
+/** Answers the workload lanes one app owns.
+ *
+ * @param app the official app slug.
+ * @returns the lane rows of the app, catalog order.
+ */
+export function lanesof(app: string): readonly WorkloadLane[] {
+  return FAMILYLANES.filter((row) => row.app === app);
+}
+
+/** Answers one lane row by app and lane id.
+ *
+ * @param app the official app slug.
+ * @param lane the lane id inside the app.
+ * @returns the lane row, or undefined when the catalog carries no such
+ * lane.
+ */
+export function getlane(app: string, lane: string): WorkloadLane | undefined {
+  return FAMILYLANES.find((row) => row.app === app && row.lane === lane);
+}
+
+/** Joins one lane row against the registry of record: the nuclear law
+ * made executable — the demand rides the join resolver, the candidates
+ * answer best-first and the verdict is computed, never declared.
+ *
+ * @param row the lane row to join.
+ * @returns the answered join: the row, the verdict and the candidates.
+ */
+export function lanejoin(row: WorkloadLane): LaneJoin {
+  const candidates = resolvejoin({
+    base: "max",
+    gpu: row.demand.gpu,
+    network: row.demand.network,
+    isolation: row.demand.isolation,
+    bootbudget: row.demand.bootbudget,
+  });
+  const livecount = candidates.filter((modality) => modality.state === "live").length;
+  const verdict: LaneVerdict = livecount > 0 ? "dispatchable" : candidates.length > 0 ? "planned-only" : "unresolved";
+  return { lane: row, verdict, candidates, livecount };
+}
+
+/** Joins one lane of one app by id — the surface the api route and the
+ * app mirrors read.
+ *
+ * @param app the official app slug.
+ * @param lane the lane id inside the app.
+ * @returns the answered join, or undefined when the catalog carries no
+ * such lane.
+ */
+export function familyjoin(app: string, lane: string): LaneJoin | undefined {
+  const row = getlane(app, lane);
+  return row === undefined ? undefined : lanejoin(row);
+}
+
+/** One app's workload answer: the lanes, the joins and the honest counts. */
+export type AppWorkloadReport = {
+  /** The official app slug. */
+  app: string;
+  /** The lane count the app owns. */
+  lanes: number;
+  /** The lanes whose join answered at least one live modality. */
+  dispatchable: number;
+  /** The lanes whose join answered only planned records. */
+  plannedonly: number;
+  /** The lanes whose join answered nothing (a calibration defect). */
+  unresolved: number;
+  /** The lanes whose heavy pass still walks the app surface. */
+  applane: number;
+  /** The lanes whose heavy pass already walks an engine surface. */
+  enginelane: number;
+  /** The per-lane joins, catalog order. */
+  joins: readonly LaneJoin[];
+};
+
+/** The family workload report: the honest census of every app's lanes
+ * against the registry of record — the work order the next waves read.
+ * */
+export type FamilyWorkloadReport = {
+  /** The official app count the catalog covers. */
+  apps: number;
+  /** The total lane count of the catalog. */
+  lanes: number;
+  /** The lanes whose join answered at least one live modality. */
+  dispatchable: number;
+  /** The lanes whose join answered only planned records (the gpu waits). */
+  plannedonly: number;
+  /** The lanes whose join answered nothing. */
+  unresolved: number;
+  /** The lanes whose heavy pass still walks the app surface — the honest
+   * migration list the next waves work through. */
+  applanemigration: number;
+  /** The per-app reports, catalog order. */
+  perapp: readonly AppWorkloadReport[];
+};
+
+/** Computes the honest family workload report from the catalog and the
+ * registry — every count derived, nothing hardcoded, so the report can
+ * never drift from either surface.
+ *
+ * @returns the family census of the workload law.
+ */
+export function workloadreport(): FamilyWorkloadReport {
+  const perapp: AppWorkloadReport[] = [];
+  let dispatchable = 0;
+  let plannedonly = 0;
+  let unresolved = 0;
+  let applanemigration = 0;
+  for (const app of CATALOGAPPS) {
+    const joins = lanesof(app).map(lanejoin);
+    const dispatchablecount = joins.filter((join) => join.verdict === "dispatchable").length;
+    const plannedonlycount = joins.filter((join) => join.verdict === "planned-only").length;
+    const unresolvedcount = joins.filter((join) => join.verdict === "unresolved").length;
+    const applanecount = joins.filter((join) => join.lane.today === "app-lane").length;
+    dispatchable += dispatchablecount;
+    plannedonly += plannedonlycount;
+    unresolved += unresolvedcount;
+    applanemigration += applanecount;
+    perapp.push({
+      app,
+      lanes: joins.length,
+      dispatchable: dispatchablecount,
+      plannedonly: plannedonlycount,
+      unresolved: unresolvedcount,
+      applane: applanecount,
+      enginelane: joins.length - applanecount,
+      joins,
+    });
+  }
+  return {
+    apps: CATALOGAPPS.length,
+    lanes: FAMILYLANES.length,
+    dispatchable,
+    plannedonly,
+    unresolved,
+    applanemigration,
+    perapp,
+  };
+}

package/dist/App.d.ts

@@ -1,5 +0,0 @@
-import '@fontsource-variable/geist-mono';
-import '@fontsource-variable/inter';
-import './Sol/sol.css';
-declare function App(): import("react").JSX.Element;
-export default App;

package/dist/App.js

@@ -1,52 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * App — the global anchor (layer 1 of the anchor architecture) and the only
- * TSX outside the theme. The root manages the themes as single files: it
- * imports only the theme anchor (Sol/Sol.tsx — the file named after the theme
- * folder, beside Sol/sol.css) and the theme stylesheet, wraps the anchor in
- * the global concerns it owns (the error boundary, the theme and tooltip
- * providers, the toaster and the wouter router provider) and renders it. The
- * whole route tree lives behind the theme anchor; no page or component of the
- * theme is ever imported here.
- */
-import { createRoot } from 'react-dom/client';
-import { Router as WouterRouter } from 'wouter';
-import Sol from './Sol/Sol';
-import { ErrorBoundary, ThemeProvider, Toaster, TooltipProvider } from './Sol/shell/Shell.tsx';
-import '@fontsource-variable/geist-mono';
-import '@fontsource-variable/inter';
-import './Sol/sol.css';
-import { seedlabels } from './labels';
-// the copy law rides the boot: the seed refreshes the label store rows
-// (translated rows protected) before the first paint answers
-if (typeof window !== 'undefined')
-    void seedlabels().catch(() => { });
-// NOTE: About Theme
-// - First choose a default theme according to your design style (dark or light bg), than change color palette in Sol/sol.css
-//   to keep consistent foreground/background color across components
-// - If you want to make theme switchable, pass `switchable` ThemeProvider and use `useTheme` hook
-/** The router base derives from the declared base path so the same build serves
- * every host. A relative base ("./") cannot name the folder it lands in, but the
- * dispatcher always boots cold links at the application root first — so the
- * folder prefix of the boot pathname is exactly the router base (absolute, so
- * wouter never has to match against a relative prefix). The absolute bases
- * carry through unchanged. */
-function routerBase() {
-    const declaredBase = import.meta.env.BASE_URL;
-    if (declaredBase !== '/' && declaredBase !== './')
-        return declaredBase.replace(/\/$/, '');
-    const bootPath = window.location.pathname.replace(/index\.html$/, '').replace(/\/$/, '');
-    return bootPath === '' ? '' : bootPath;
-}
-function App() {
-    return (_jsx(ErrorBoundary, { children: _jsx(ThemeProvider, { defaultTheme: "dark", children: _jsxs(TooltipProvider, { children: [_jsx(Toaster, {}), _jsx(WouterRouter, { base: routerBase(), children: _jsx(Sol, {}) })] }) }) }));
-}
-/* The self-mount: the app owns its bootstrap — the retired main.tsx
- * wrapper is gone, so this module is the single entry the html loads
- * (the doctrine of the 2.1.0 universal interface: one tsx app, the
- * router and the mount live together). */
-const rootmount = typeof document !== 'undefined' ? document.getElementById('root') : null;
-if (rootmount) {
-    createRoot(rootmount).render(_jsx(App, {}));
-}
-export default App;

package/dist/Sol/Sol.d.ts

@@ -1,3 +0,0 @@
-/** The route tree of the theme: the entry flow (intro, onboarding) before
- * the catch-all that mounts the window over every page route. */
-export default function Sol(): import("react").JSX.Element;

package/dist/Sol/Sol.js

@@ -1,46 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * Sol theme anchor — layer 2 of the anchor architecture.
- * The file carrying the theme folder's own name (Sol/Sol.tsx, beside
- * Sol/sol.css) is the path manager of the pages: it imports one anchor per
- * page folder (`folder/folder.tsx`, each beside the loose components its
- * folder keeps) and mounts every route and subroute of the theme. App.tsx
- * consumes only this file and the theme stylesheet; no page component is
- * ever imported outside this layer. When a theme folder changes its name
- * (Moon, Aqua), this file follows the new name and App.tsx keeps importing
- * the anchor by the folder path. Since the family window conversion the
- * theme is an APPLICATION: the entry flow opens the route table — /intro
- * (the akash-floor splash) and /onboarding (the first-run frames) — and
- * every other route renders as the content of the ONE application window
- * (the page anchors carry no chrome of their own; the window rail is the
- * only nav). The flow contract rides the home anchor's entry gate
- * (Sol/home/entrygate.tsx): "/" consults the seen flags (onboardingstate.ts)
- * before anything shows, the intro hands straight to /onboarding and the
- * onboarding lands home.
- */
-import { Route, Switch } from 'wouter';
-import AgentBrowserAnchor from './agentbrowser/agentbrowser';
-import ArchitectureAnchor from './architecture/architecture';
-import ComputeAnchor from './compute/compute';
-import ConsoleAnchor from './console/console';
-import DashboardAnchor from './dashboard/dashboard';
-import DocsAnchor from './docs/docs';
-import HomeAnchor from './home/home';
-import IntegrationsAnchor from './integrations/integrations';
-import IntroAnchor from './intro/intro';
-import LoginAnchor from './login/login';
-import NotFoundAnchor from './notfound/notfound';
-import OnboardingAnchor from './onboarding/onboarding';
-import PlaygroundAnchor from './playground/playground';
-import RegisterAnchor from './register/register';
-import { Shell } from './shell/Shell.tsx';
-/** The window stage: the ONE application window wrapping the whole page
- * route table — every existing route stays alive inside the stage. */
-function WindowStage() {
-    return (_jsx(Shell, { children: _jsxs(Switch, { children: [_jsx(Route, { path: '/', component: HomeAnchor }), _jsx(Route, { path: '/architecture', component: ArchitectureAnchor }), _jsx(Route, { path: '/agent-browser', component: AgentBrowserAnchor }), _jsx(Route, { path: '/compute', component: ComputeAnchor }), _jsx(Route, { path: '/integrations', component: IntegrationsAnchor }), _jsx(Route, { path: '/playground', component: PlaygroundAnchor }), _jsx(Route, { path: '/console', component: ConsoleAnchor }), _jsx(Route, { path: '/login', component: LoginAnchor }), _jsx(Route, { path: '/register', component: RegisterAnchor }), _jsx(Route, { path: '/dashboard', component: DashboardAnchor }), _jsx(Route, { path: '/docs', component: DocsAnchor }), _jsx(Route, { path: '/404', component: NotFoundAnchor }), _jsx(Route, { component: NotFoundAnchor })] }) }));
-}
-/** The route tree of the theme: the entry flow (intro, onboarding) before
- * the catch-all that mounts the window over every page route. */
-export default function Sol() {
-    return (_jsxs(Switch, { children: [_jsx(Route, { path: '/intro', component: IntroAnchor }), _jsx(Route, { path: '/onboarding', component: OnboardingAnchor }), _jsx(Route, { component: WindowStage })] }));
-}

package/dist/Sol/agentbrowser/agentbrowser.d.ts

@@ -1,9 +0,0 @@
-/**
- * agent browser page anchor — layer 3 of the anchor architecture.
- * The file carrying the folder's own name is the path manager of the page:
- * it imports the loose components beside it, mounts the page and re-exports
- * the public component surface. Only the theme anchor (Sol/Sol.tsx) consumes
- * this file. This anchor carries the former main component of the folder,
- * which now lives here as the page mount itself.
- */
-export default function AgentBrowser(): import("react").JSX.Element;

package/dist/Sol/agentbrowser/agentbrowser.js

@@ -1,121 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * agent browser page anchor — layer 3 of the anchor architecture.
- * The file carrying the folder's own name is the path manager of the page:
- * it imports the loose components beside it, mounts the page and re-exports
- * the public component surface. Only the theme anchor (Sol/Sol.tsx) consumes
- * this file. This anchor carries the former main component of the folder,
- * which now lives here as the page mount itself.
- */
-import { PulseRegular as Activity, ProhibitedRegular as Ban, CameraRegular as Camera, CheckmarkCircleRegular as CheckCircle2, KeyboardRegular as Keyboard, CursorRegular as MousePointer2, PlayRegular as Play, ArrowCounterclockwiseRegular as RotateCcw, DocumentTextRegular as ScrollText, WindowConsoleRegular as Terminal, } from '@fluentui/react-icons';
-// Signal & Ledger: agent browser as an event trail, evidence and deterministic replay.
-// The session console renders the rows the sessions catalog serves — the
-// documented example log of docs/logs/examplesession.json offline, the paired
-// database rows over HTTPS — never invented coordinates or counts. Every
-// word of the page itself rides the label store (labels.ts — the copy law).
-import { useEffect, useState } from 'react';
-import { PageShell } from '../shell/Shell.tsx';
-import { label, labelfill } from '../../labels.ts';
-import { agentsessions, mediaSlots, } from '../../catalog';
-/** the glyph of one event kind of the session trail. */
-function eventicon(type) {
-    if (type === 'scroll')
-        return ScrollText;
-    if (type === 'type')
-        return Keyboard;
-    return MousePointer2;
-}
-/** the value line of one event: exactly the fields the row carries. */
-function eventvalue(event) {
-    if (event.type === 'scroll')
-        return `dy ${event.dy ?? 0}`;
-    if (event.type === 'type')
-        return `key ${event.key ?? ''}`;
-    return `x ${event.x ?? 0} / y ${event.y ?? 0}`;
-}
-/** the elapsed label of one event from its relative time. */
-const eventtime = (event) => `+${event.t} ms`;
-/** one rendered event row: the glyph, the relative time, the kind and the fields. */
-function SessionEventRow({ event }) {
-    const Icon = eventicon(event.type);
-    return (_jsxs("div", { className: "console-row", children: [_jsx(Icon, { fontSize: 16 }), _jsx("span", { className: "console-time", children: eventtime(event) }), _jsx("strong", { children: event.type }), _jsx("span", { children: eventvalue(event) })] }));
-}
-/** the event trail of one session: one row per captured event. */
-function SessionTrail({ events }) {
-    return (_jsx(_Fragment, { children: events.map((event) => (_jsx(SessionEventRow, { event: event }, `${event.t}-${event.type}`))) }));
-}
-/** the captcha verdict badge of one session: the honest outcome of the run. */
-function CaptchaBadge({ verdict }) {
-    return (_jsxs("span", { className: verdict.passed ? 'console-pass' : 'console-denied', children: [verdict.passed ? _jsx(CheckCircle2, { fontSize: 14 }) : _jsx(Ban, { fontSize: 13 }), " ", verdict.kind, ' ', label(verdict.passed ? 'agentbrowser.captcha.passed' : 'agentbrowser.captcha.failed')] }));
-}
-/** the principle cards beside the console: the glyph is presentation code,
- * the words ride the store (agentbrowser.principle.*). */
-const principles = [
-    { icon: Camera, titlekey: 'agentbrowser.principle.dom.title', bodykey: 'agentbrowser.principle.dom.body' },
-    {
-        icon: RotateCcw,
-        titlekey: 'agentbrowser.principle.replay.title',
-        bodykey: 'agentbrowser.principle.replay.body',
-    },
-    {
-        icon: Play,
-        titlekey: 'agentbrowser.principle.evidence.title',
-        bodykey: 'agentbrowser.principle.evidence.body',
-    },
-];
-export default function AgentBrowser() {
-    const [media, setMedia] = useState(undefined);
-    const [sessions, setSessions] = useState(null);
-    useEffect(() => {
-        void mediaSlots().then((rows) => setMedia(rows.find((slot) => slot.id === 'media.agentbrowser.trace')));
-    }, []);
-    useEffect(() => {
-        let live = true;
-        agentsessions()
-            .then((rows) => {
-            if (live)
-                setSessions(rows);
-        })
-            .catch(() => {
-            if (live)
-                setSessions([]);
-        });
-        return () => {
-            live = false;
-        };
-    }, []);
-    const session = sessions?.[0] ?? null;
-    const lastt = session ? session.events[session.events.length - 1]?.t ?? 0 : 0;
-    const sessionlabel = session ? session.session.id : label('agentbrowser.console.reading');
-    /** the trimmed json projection of the served row (the docs/logs shape). */
-    const sessionsummary = session
-        ? JSON.stringify({
-            version: session.version,
-            session: {
-                id: session.session.id,
-                browser: session.session.browser,
-            },
-            events: session.events.map((event) => event.type),
-            captcha: session.captcha,
-        }, null, 2)
-        : label('agentbrowser.console.waitingSession');
-    return (_jsxs(PageShell, { section: label('agentbrowser.shell.section'), label: label('agentbrowser.shell.label'), title: label('agentbrowser.shell.title'), intro: label('agentbrowser.shell.intro'), media: media, children: [_jsxs("section", { className: "content-section split-content", children: [_jsxs("div", { children: [_jsx("p", { className: "eyebrow", children: label('agentbrowser.split.eyebrow') }), _jsx("h2", { className: "section-title", children: label('agentbrowser.split.title') })] }), _jsxs("div", { className: "prose-copy", children: [_jsx("p", { children: label('agentbrowser.split.body1') }), _jsx("p", { children: label('agentbrowser.split.body2') })] })] }), _jsxs("section", { className: "content-section browser-grid", children: [_jsxs("div", { className: "session-console", children: [_jsxs("div", { className: "console-head", children: [_jsxs("span", { children: [_jsx(Terminal, { fontSize: 14 }), ' ', labelfill('agentbrowser.console.session', {
-                                                id: sessionlabel,
-                                            })] }), session ? _jsx(CaptchaBadge, { verdict: session.captcha }) : null] }), _jsx("div", { className: "console-rows", children: session === null ? (_jsxs("div", { className: "console-row", "aria-live": "polite", children: [_jsx(Activity, { fontSize: 16 }), _jsx("span", { className: "console-time" }), _jsx("strong", { children: label('agentbrowser.console.catalog') }), _jsx("span", { children: label('agentbrowser.console.waiting') })] })) : session.events.length === 0 ? (_jsxs("div", { className: "console-row", "aria-live": "polite", children: [_jsx(Activity, { fontSize: 16 }), _jsx("span", { className: "console-time" }), _jsx("strong", { children: label('agentbrowser.console.catalog') }), _jsx("span", { children: label('agentbrowser.console.empty') })] })) : (_jsxs(_Fragment, { children: [_jsx(SessionTrail, { events: session.events }), _jsxs("div", { className: "console-row", children: [_jsx(Activity, { fontSize: 16 }), _jsxs("span", { className: "console-time", children: ["+", lastt, " ms"] }), _jsx("strong", { children: label('agentbrowser.console.metrics') }), _jsx("span", { children: labelfill('agentbrowser.console.events', {
-                                                        n: String(session.events.length),
-                                                        s: (lastt / 1000).toFixed(1),
-                                                    }) })] })] })) }), _jsxs("div", { className: "console-footer", children: [_jsx("span", { children: labelfill('agentbrowser.console.seed', {
-                                            seed: session
-                                                ? session.session.seed
-                                                : label('agentbrowser.console.na'),
-                                        }) }), _jsx("span", { children: labelfill('agentbrowser.console.browser', {
-                                            browser: session
-                                                ? session.session.browser
-                                                : label('agentbrowser.console.na'),
-                                        }) })] })] }), _jsx("div", { className: "browser-principles", children: principles.map((principle) => {
-                            const Icon = principle.icon;
-                            return (_jsxs("div", { className: "principle-card", children: [_jsx(Icon, { fontSize: 19 }), _jsxs("div", { children: [_jsx("strong", { children: label(principle.titlekey) }), _jsx("span", { children: label(principle.bodykey) })] })] }, principle.titlekey));
-                        }) })] }), _jsxs("section", { className: "content-section", children: [_jsxs("div", { className: "content-section-heading", children: [_jsx("p", { className: "eyebrow", children: labelfill('agentbrowser.json.eyebrow', {
-                                    version: String(session ? session.version : 1),
-                                }) }), _jsx("span", { className: "mono-label", children: label('agentbrowser.json.mono') })] }), _jsx("pre", { className: "code-block", children: _jsx("code", { children: sessionsummary }) })] })] }));
-}

package/dist/Sol/architecture/architecture.d.ts

@@ -1,9 +0,0 @@
-/**
- * architecture page anchor — layer 3 of the anchor architecture.
- * The file carrying the folder's own name is the path manager of the page:
- * it imports the loose components beside it, mounts the page and re-exports
- * the public component surface. Only the theme anchor (Sol/Sol.tsx) consumes
- * this file. This anchor carries the former main component of the folder,
- * which now lives here as the page mount itself.
- */
-export default function Architecture(): import("react").JSX.Element;