@wenathlan/saddle 2.0.153 → 2.0.155

package/dist/vite.config.d.ts

@@ -1,3 +0,0 @@
-/** Style: saddle Sol — the absorbed console surface on the family theme machinery: static-first vite build that emits the hashed bundles straight at the app root, with a repository-scoped base path and preview-safe host handling. */
-declare const _default: import("vite").UserConfig;
-export default _default;

package/dist/vite.config.js

@@ -1,43 +0,0 @@
-/** Style: saddle Sol — the absorbed console surface on the family theme machinery: static-first vite build that emits the hashed bundles straight at the app root, with a repository-scoped base path and preview-safe host handling. */
-import path from 'node:path';
-import tailwindcss from '@tailwindcss/vite';
-import react from '@vitejs/plugin-react';
-import { defineConfig } from 'vite';
-function themeBasePath(value) {
-    const candidate = value?.trim() || '/';
-    if (candidate === '.' || candidate === './')
-        return './';
-    return candidate === '/' ? candidate : `/${candidate.replace(/^\/+|\/+$/g, '')}/`;
-}
-export default defineConfig({
-    base: themeBasePath(process.env.VITE_BASE_PATH),
-    plugins: [react(), tailwindcss()],
-    resolve: {
-        alias: {
-            // the theme sources live in the Sol folder of this app root.
-            '@': path.resolve(import.meta.dirname, 'Sol'),
-            // The playground consumes the engine source here so the build never
-            // depends on a prebuilt dist directory.
-            '@saddle/isolation': path.resolve(import.meta.dirname, 'isolation.ts'),
-        },
-    },
-    root: import.meta.dirname,
-    envDir: import.meta.dirname,
-    build: {
-        outDir: path.resolve(import.meta.dirname, '.'),
-        emptyOutDir: false,
-        assetsDir: '',
-    },
-    /** the theme sources live in the Sol folder of this app root: the pages import
-     * the root engine logics (api, auth, db, mesh, sandbox) across the theme
-     * boundary, and the playground consumes the root isolation module, so the
-     * dev server allows this single root. */
-    server: {
-        fs: {
-            allow: [import.meta.dirname],
-        },
-        host: true,
-        strictPort: false,
-        allowedHosts: true,
-    },
-});

package/dist/vitest.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("vite").UserConfig;
-export default _default;

package/dist/vitest.config.js

@@ -1,25 +0,0 @@
-import { defineConfig } from "vitest/config";
-export default defineConfig({
-    test: {
-        environment: "node",
-        include: ["tests/*.test.ts"],
-        globals: true,
-        testTimeout: 15000,
-        coverage: {
-            provider: "v8",
-            reporter: ["text", "json", "html"],
-            include: ["src/**/*.ts"],
-            exclude: [
-                "tests/*.test.ts",
-                "scripts/**",
-                "web/**",
-                "production/**",
-                "docs/**",
-                "node_modules/**",
-                "dist/**",
-                "coverage/**",
-            ],
-            thresholds: { lines: 60, functions: 50, branches: 50, statements: 60 },
-        },
-    },
-});

package/dist/webserver.d.ts

@@ -1,166 +0,0 @@
-#!/usr/bin/env node
-/**
- * webserver.ts — self-hosted node api for the saddle web console (the merged e2ugh sandbox surface, v7-BACK).
- *
- * pure node:http, zero dependencies, esm. the server serves the react
- * spa build (the hashed bundles vite emits straight at the app root,
- * produced once by "npm run web:build";
- * content types parsed from web/mime.types at boot) with the index.html
- * fallback for client routes, and it exposes the /api/v1 contract:
- * health, spec catalogs read from the repository json files, in-memory
- * sandboxes with the created ->
- * running state machine persisted to sqlite, exec through the very
- * same browser-pure dispatcher (sandbox.ts) with the persistent
- * per-sandbox workspace filesystem (sandboxfiles table, quota capped,
- * data stays with the sandbox id across restarts), the auth surface
- * (register/login/logout/me backed by scrypt and sessions in db.ts),
- * the edge execution plane (the modality catalog census, the probed
- * lane report and the server-side edge runs riding the modality
- * lanes), the signed mesh surface (register/heartbeat/nodes verified by
- * mesh.ts), the admin surface (overview/users/nodes/sandboxes/audit)
- * and the events poll for the dashboard. per the project rules there
- * is no serverless function anywhere: this file is the whole backend
- * and runs on any plain node host (docker, vps, caddy reverse proxy).
- * the backend sources (server.ts, db.ts, auth.ts, mesh.ts, sandbox.ts)
- * stay at the app root beside the served root, so the extension denylist
- * keeps them unreachable by the static resolver.
- *
- * contexts (28): types, httpserver, portselection, noderole,
- * staticfiles, mimetypes, contenttypes, cacheheaders, securityheaders,
- * cors, jsonio, apierrors, health, speccatalogs, specscache, edgeplane,
- * authroutes, sandboxes, sandboxfs, statemachine, ttlreaper,
- * execendpoint, filesroutes, meshroutes, adminroutes, eventsroute,
- * requestlogging, gracefulshutdown.
- *
- * rules: lowercase identifiers, english jsdoc in third person, no emoji,
- * try/catch on every fallible path, standardized {error:{code,message}}
- * json failures, no hardcoded localhost address, host and port resolved
- * once at boot from argv/env with a random 30000-59999 default.
- */
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { SandboxFs, SandboxState } from './sandbox.ts';
-import type { WorkspaceUsage } from './db.ts';
-import type { SessionUser } from './auth.ts';
-/** sandbox creation request carried by POST /api/v1/sandboxes; the cpu
- * model, gpu and mig values come from the reviewed catalogs. the
- * declaration fields (base, os, arch, form, networking, vgpu, diskgb,
- * timeoutseconds) ride the sandboxprofile.ts plane: any of them present
- * switches the request to the resolved spec path, none keeps the exact
- * legacy behavior. */
-export type SandboxCreateBody = {
-    model?: string;
-    vcpus?: number;
-    ramgb?: number;
-    gpu?: string;
-    mig?: string;
-    quotamb?: number;
-    base?: string;
-    os?: string;
-    arch?: string;
-    form?: string;
-    networking?: string;
-    vgpu?: boolean;
-    diskgb?: number;
-    timeoutseconds?: number;
-};
-/** the resolved sandbox spec stored on the record and echoed by the views.
- * the declaration fields stay optional so legacy rows (and legacy
- * callers) keep their shape untouched. */
-export type SandboxSpecView = {
-    model: string;
-    vcpus: number;
-    ramgb: number;
-    gpu: string;
-    mig: string;
-    os?: string;
-    arch?: string;
-    form?: string;
-    networking?: string;
-    vgpu?: boolean;
-    diskgb?: number | null;
-    timeoutseconds?: number;
-};
-/** the in-memory sandbox record: the api lifecycle fields plus the
- * private engine state consumed by dispatch and the dispatcher
- * filesystem context bound to the sqlite workspace table. */
-export type SandboxRecord = {
-    id: string;
-    userid: string;
-    state: 'created' | 'running' | 'destroyed' | 'expired';
-    spec: SandboxSpecView;
-    createdat: number;
-    startedat: number | null;
-    expiresat: number;
-    execcount: number;
-    lastcommand: string | null;
-    usage: WorkspaceUsage;
-    engine: SandboxState;
-    fscontext: {
-        quota: number;
-        fs: SandboxFs;
-    };
-};
-/** the json-safe status document answered by the sandbox routes. */
-export type SandboxPublicView = {
-    id: string;
-    state: string;
-    model: string;
-    vcpus: number;
-    ramgb: number;
-    gpu: string;
-    mig: string;
-    spec: SandboxSpecView;
-    createdAt: string;
-    startedAt: string | null;
-    expiresAt: string;
-    ttlSeconds: number;
-    execCount: number;
-    lastCommand: string | null;
-    usage: WorkspaceUsage;
-};
-/** one shelf row answered by GET /api/v1/sandboxes. */
-export type SandboxShelfRow = {
-    id: string;
-    state: string;
-    model: string;
-    vcpus: number;
-    ramgb: number;
-    gpu: string;
-    createdAt: string;
-    expiresAt: string | null;
-    files: number;
-    bytes: number;
-    resumable: boolean;
-};
-/**
- * in-memory sandbox store: id -> record. the record carries the api
- * lifecycle fields plus the private engine state consumed by dispatch
- * and the owning userid persisted in the sandboxes table.
- */
-declare const sandboxes: Map<string, SandboxRecord>;
-/**
- * creates a sandbox record: id, the created -> running state machine with
- * the 125 ms firecracker ramp, the resolved spec, the owning user and
- * the dispatcher state built by createsandboxstate. the row is mirrored
- * into the sqlite sandboxes table. malformed requests throw errors
- * carrying status and code fields consumed by the route handler.
- *
- * @param body the creation request; the cpu
- *   model comes from the reviewed catalog, quotamb picks the persistent
- *   workspace quota (4-256 MiB).
- * @param user the authenticated owner.
- * @returns the stored sandbox record.
- */
-declare function createsandbox(body: SandboxCreateBody, user: SessionUser): SandboxRecord;
-/**
- * handles one /api/v1 request.
- *
- * @param req the incoming request.
- * @param res the outgoing response.
- * @param url the parsed request url.
- * @returns resolves when the response is written.
- */
-declare function handleapi(req: IncomingMessage, res: ServerResponse, url: URL): Promise<void>;
-/** the http server: static files plus the /api/v1 router. */
-declare const server: import("node:http").Server<typeof IncomingMessage, typeof ServerResponse>;
-export { server, sandboxes, createsandbox, handleapi };