@wenathlan/saddle 2.0.154 → 2.0.159

package/scheduler.ts

@@ -44,7 +44,7 @@ import {
   schedextinfo,
   tenantcgroupbuilder,
   tenantqosmap,
-} from './virtualization.js';
+} from './virtual.ts';
 
 /** stable short sha256 digest for cache keys and reload detection. */
 function digest(input: string | Uint8Array): string {

package/server.ts

@@ -0,0 +1,52 @@
+/**
+ * server.ts — the Node HTTP server surface.
+ *
+ * This file is the v2.0.0 grand-merge consolidation of the former nested
+ * folders of the repository (server) into the single
+ * root-level domain file of the saddle family standard: one optimized
+ * TypeScript file per correlated domain, ordinal sections, JSDoc on every
+ * block, intra-domain imports dissolved, cross-domain imports rewritten to
+ * ./<domain>.js. Every capability of every source file is preserved here;
+ * the pure re-export barrels (none in this domain) folded their surface into this file directly.
+ */
+
+import { createServer } from "node:http";
+
+/* ════════════════════════════════════════════════════════════════════ */
+/* Section 1: server/node.ts — node server is an optional adapter around the universal service contract. */
+/* ════════════════════════════════════════════════════════════════════ */
+/**
+ * node server is an optional adapter around the universal service contract.
+ */
+
+/** Creates a Node HTTP adapter with explicit host, port, and request handler. */
+export function nodeserver(options = {}) {
+  if (!options.host || !Number.isInteger(options.port) || options.port < 1) throw new TypeError("node server requires host and port");
+  if (typeof options.handle !== "function") throw new TypeError("node server requires handle");
+  /* Request translation stays inside the Node adapter. */
+  const server = createServer(async (request, response) => {
+    try {
+      const chunks = [];
+      for await (const chunk of request) chunks.push(chunk);
+      const body = Buffer.concat(chunks).toString("utf8");
+      const headers = new Headers(request.headers);
+      const webrequest = new Request(new URL(request.url ?? "/", `http://${options.host}:${options.port}`), { method: request.method, headers, body: body || undefined });
+      const result = await options.handle(webrequest);
+      response.statusCode = result.status;
+      result.headers.forEach((value, key) => {
+        response.setHeader(key, value);
+      });
+      response.end(Buffer.from(await result.arrayBuffer()));
+    } catch (error) {
+      response.statusCode = 500;
+      response.setHeader("content-type", "application/json");
+      response.end(JSON.stringify({ error: error.message }));
+    }
+  });
+  /* Lifecycle methods keep the server optional for library consumers. */
+  return {
+    server,
+    listen() { return new Promise((resolve, reject) => { server.once("error", reject); server.listen(options.port, options.host, () => resolve({ host: options.host, port: options.port })); }); },
+    close() { return new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve())); }
+  };
+}

package/tsconfig.json

@@ -1,11 +1,11 @@
-// the saddle typescript baseline (the engine emission contract over the
-// app root and the Sol theme: one project covers both).
-// the grand-merge engine sources carry the loose typing baseline the
-// upstream saddle authored them under (strict: false with noCheck: true),
-// and the build engine emits the dist tree through this project — the
-// upstream options answer verbatim (outDir dist, NodeNext, declaration),
-// with the theme options (jsx, the vite client types) riding beside them
-// so the one project keeps covering the Sol surface.
+// the saddle typescript baseline (the source-is-library law the vault
+// doctrine brought to the family: the .ts sources ARE the engine — node 26
+// strips the types, the explicit .ts imports resolve natively, the browser
+// lanes bundle through vite and nothing ever emits a dist tree).
+// the grand-merge engine sources keep the loose typing baseline the
+// upstream saddle authored them under (strict: false, noCheck: true), with
+// the theme options (jsx, the vite client types) riding beside them so the
+// one project keeps covering the Sol surface.
 {
   "compilerOptions": {
     "module": "NodeNext",
@@ -13,9 +13,8 @@
     "target": "ES2024",
     "lib": ["ES2024", "dom", "dom.iterable"],
     "jsx": "react-jsx",
-    "outDir": "dist",
-    "rootDir": ".",
-    "declaration": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
     "strict": false,
     "noCheck": true,
     "esModuleInterop": true,
@@ -25,10 +24,10 @@
     "forceConsistentCasingInFileNames": true,
     "types": ["node", "vite/client"],
     "paths": {
-      "@/*": ["./Sol/*", "./*"],
+      "@/*": ["./sol/*", "./*"],
       "@saddle/isolation": ["./isolation.ts"]
     }
   },
-  "include": ["*.ts", "*.tsx", "Sol/**/*.ts", "Sol/**/*.tsx", "docs/example-*.ts", "jsdom.d.ts"],
+  "include": ["*.ts", "*.tsx", "sol/**/*.ts", "sol/**/*.tsx", "docs/example-*.ts"],
   "exclude": ["node_modules", "dist", "**/*.test.ts", "coverage", "web", "tests", "build"]
 }