tina4-nodejs 3.13.97 → 3.13.99

package/packages/orm/src/types.ts

@@ -1,4 +1,4 @@
-export type FieldType = "string" | "integer" | "number" | "numeric" | "boolean" | "datetime" | "text" | "json" | "foreignKey";
+export type FieldType = "string" | "integer" | "number" | "numeric" | "decimal" | "boolean" | "datetime" | "text" | "json" | "foreignKey";
 
 export interface FieldDefinition {
   type: FieldType;
@@ -11,6 +11,15 @@ export interface FieldDefinition {
   min?: number;
   max?: number;
   pattern?: string;
+  /**
+   * For type "decimal": the fixed precision/scale of a real DECIMAL(p, s)
+   * column. `number`/`numeric` stay a floating type (the documented money
+   * guidance); a `decimal` field keeps the declared scale in the COLUMN, so
+   * createTable emits DECIMAL(precision, scale) — identical on
+   * PostgreSQL/MySQL/MSSQL/Firebird/SQLite. Default 10 / 2 when omitted.
+   */
+  precision?: number;
+  scale?: number;
   /** For type "foreignKey": the referenced model name (string) */
   references?: string;
   /** For type "foreignKey": override the has-many property name on the referenced model */
@@ -54,6 +63,12 @@ export interface ColumnInfo {
   nullable?: boolean;
   default?: unknown;
   primaryKey?: boolean;
+  /**
+   * ADR-0044 amendment (Feature 5 Decision 7, 2026-08-10): null for a
+   * non-key column; for a composite key this is the 1-based DECLARED
+   * PRIMARY KEY (...) order, not table-column order.
+   */
+  primaryKeyPosition?: number | null;
 }
 
 export interface DatabaseResult {
@@ -65,31 +80,62 @@ export interface DatabaseResult {
   error?: string;
 }
 
+/**
+ * ADR-0044 (feature 3, plan/v3/fixtures/adapter_contract.json): the exact
+ * fourteen adapter capabilities every DatabaseAdapter implementation must
+ * provide (DBA-S01). Kept as data so the conformance suite can check it
+ * without a second hand-maintained copy of the list.
+ */
+export const REQUIRED_ADAPTER_CAPABILITIES = [
+  "connect", "close", "getDatabaseType",
+  "execute", "executeMany", "fetch", "fetchOne",
+  "startTransaction", "commit", "rollback", "autocommit",
+  "getTables", "getColumns", "tableExists",
+] as const;
+
+/**
+ * ADR-0044 NOT_REQUIRED_ON_ADAPTER (DBA-S03): engine-neutral composition that
+ * the adapter CONTRACT does not require. Node keeps these as REQUIRED
+ * TypeScript interface members anyway (unlike Python/PHP/Ruby's stricter
+ * runtime reflection) because `database.ts`/`cachedDatabase.ts` call them
+ * directly at dozens of sites with no optional-chaining guard, so making them
+ * TS-optional ripples into a much larger refactor than this pass covers;
+ * this constant records the ADR's INTENT for the conformance suite to check
+ * even though the compiler will not enforce their absence.
+ */
+export const NOT_REQUIRED_ON_ADAPTER = [
+  "query", "insert", "update", "delete", "truncate", "fetchAll",
+  "createTable", "addColumn", "lastInsertId", "error", "sqlTranslation",
+] as const;
+
 export interface DatabaseAdapter {
+  /** Connect (ADR-0044 canonical lifecycle name). May be sync or async. */
+  connect(): void | Promise<void>;
+
+  /** Return the canonical, credential-free engine name ("sqlite", "postgres", ...). */
+  getDatabaseType(): string;
+
   /** Execute a statement (INSERT, UPDATE, DELETE, DDL). */
   execute(sql: string, params?: unknown[]): unknown;
 
-  /** Execute a single SQL statement with multiple parameter sets (batch). */
-  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastId?: number | bigint };
-
-  /** Query rows. */
-  query<T = Record<string, unknown>>(sql: string, params?: unknown[]): T[];
+  /**
+   * Execute a single SQL statement with multiple parameter sets as ONE
+   * aggregate result (ADR-0044). The shared write shape `DatabaseResult`
+   * ({success, affectedRows, lastId?}) is the target; the pre-ADR-0044 async
+   * adapters (Postgres/MySQL/MSSQL/Firebird/Mongo) still return their
+   * original `{totalAffected, lastId?}` shape internally today — the union
+   * covers both while `adapterExecuteMany()` in database.ts normalises
+   * whichever shape it receives at the one chokepoint every public batch
+   * write flows through.
+   */
+  executeMany(sql: string, paramsList: unknown[][]): DatabaseResult | { totalAffected: number; lastId?: number | bigint };
 
-  /** Fetch rows with optional pagination (limit/skip). */
+  /** Fetch rows with optional pagination (limit/skip). Native list, no envelope. */
   fetch<T = Record<string, unknown>>(sql: string, params?: unknown[], limit?: number, skip?: number): T[];
 
-  /** Fetch a single row or null. */
+  /** Fetch a single row or null. No pagination count probe. */
   fetchOne<T = Record<string, unknown>>(sql: string, params?: unknown[]): T | null;
 
-  /** Insert one or more rows into a table, returns result with lastId. */
-  insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): DatabaseResult;
-
-  /** Update rows in a table matching filter (object or string WHERE), returns affected row count. */
-  update(table: string, data: Record<string, unknown>, filter: Record<string, unknown> | string, params?: unknown[]): DatabaseResult;
-
-  /** Delete rows from a table matching filter (object, string WHERE, or array of objects). */
-  delete(table: string, filter: Record<string, unknown> | string | Record<string, unknown>[], params?: unknown[]): DatabaseResult;
-
   /** Start a transaction. */
   startTransaction(): void;
 
@@ -99,24 +145,54 @@ export interface DatabaseAdapter {
   /** Rollback the current transaction. */
   rollback(): void;
 
+  /**
+   * Native boolean, readable and writable. A plain field is the idiomatic JS
+   * shape for "readable and writable" — no getter/setter ceremony needed.
+   */
+  autocommit: boolean;
+
+  /**
+   * ADR-0044 / DBA-P02: whether this adapter's deployment can guarantee an
+   * atomic multi-row batch write. Every built-in adapter defaults true (see
+   * each adapter's field initializer); a deployment that genuinely cannot (a
+   * standalone MongoDB without a replica set is the motivating real case)
+   * sets this false so executeMany rejects BEFORE the first write.
+   */
+  supportsAtomicBatch?: boolean;
+
   /** List all tables in the database. */
   getTables(): string[];
 
   /** List columns with types for a table. */
   getColumns(table: string): ColumnInfo[];
 
-  /** Get the last inserted id (auto-increment integer, or a UUID/string PK). */
-  lastInsertId(): number | bigint | string | null;
-
   /** Close the connection. */
   close(): void;
 
   /** Check if a table exists. */
   tableExists(name: string): boolean;
 
-  /** Create a table from field definitions. */
+  // -- Engine-neutral composition — NOT part of the ADR-0044 CONTRACT, but
+  // kept as required TS members for now (see NOT_REQUIRED_ON_ADAPTER above).
+
+  /** Insert one or more rows into a table, returns result with lastId. */
+  insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): DatabaseResult;
+
+  /** Update rows in a table matching filter (object or string WHERE), returns affected row count. */
+  update(table: string, data: Record<string, unknown>, filter: Record<string, unknown> | string, params?: unknown[]): DatabaseResult;
+
+  /** Delete rows from a table matching filter (object, string WHERE, or array of objects). */
+  delete(table: string, filter: Record<string, unknown> | string | Record<string, unknown>[], params?: unknown[]): DatabaseResult;
+
+  /** Query rows (legacy convenience, superseded by fetch). */
+  query<T = Record<string, unknown>>(sql: string, params?: unknown[]): T[];
+
+  /** Create a table from field definitions (legacy, DDL composition lives above the adapter). */
   createTable(name: string, columns: Record<string, FieldDefinition>): void;
 
+  /** Get the last inserted id (legacy — prefer DatabaseResult.lastId from execute/executeMany). */
+  lastInsertId(): number | bigint | string | null;
+
   /** Get raw column info (legacy, used by migration). */
   getTableColumns?(name: string): Array<{ name: string; type: string }>;
 

package/packages/orm/src/validation.ts

@@ -50,7 +50,11 @@ export function validate(
           }
           const regex = compiledPatterns.get(name);
           if (regex && !regex.test(value)) {
-            errors.push({ field: name, message: `does not match required pattern` });
+            // Feature 19 (VALID-TWO-MESSAGES): one canonical wording per rule
+            // across BOTH validators. The request Validator says "does not match
+            // the required format"; the ORM validator must say the same so a
+            // client keying on the message matches either surface.
+            errors.push({ field: name, message: `does not match the required format` });
           }
         }
         break;

package/packages/swagger/dist/index.js

@@ -1,5 +1,6 @@
 // src/generator.ts
 var WRITE_METHODS = /* @__PURE__ */ new Set(["post", "put", "patch", "delete"]);
+var INTERNAL_PREFIXES = ["/swagger", "/__dev", "/__feedback", "/ai", "/rag", "/vision", "/embed", "/image"];
 var registeredSchemes = {};
 var registeredSchemas = {};
 function addSecurityScheme(name, definition) {
@@ -239,7 +240,7 @@ function routeRequiresAuth(route, method) {
   return route.secure === true;
 }
 function isIncludedPath(rawPath, include, exclude) {
-  for (const internal of ["/swagger", "/__dev"]) {
+  for (const internal of INTERNAL_PREFIXES) {
     if (rawPath === internal || rawPath.startsWith(internal + "/")) return false;
   }
   if (include.length > 0 && !include.some((p) => rawPath === p || rawPath.startsWith(p))) {
@@ -440,7 +441,7 @@ function uniqueOperationId(method, openApiPath, seen) {
 
 // src/ui.ts
 function swaggerUiCdn() {
-  return (process.env.TINA4_SWAGGER_UI_CDN ?? "https://unpkg.com/swagger-ui-dist@5").replace(/\/+$/, "");
+  return (process.env.TINA4_SWAGGER_UI_CDN ?? "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5").replace(/\/+$/, "");
 }
 var SWAGGER_UI_HTML = (specUrl) => `<!DOCTYPE html>
 <html lang="en">

package/packages/swagger/src/generator.ts

@@ -20,6 +20,21 @@ interface OpenAPISpec {
 
 const WRITE_METHODS = new Set(["post", "put", "patch", "delete"]);
 
+/**
+ * Framework-internal route prefixes that are NEVER part of an application's
+ * public API document. SHARED across all four frameworks (SWAG-EXCLUSION-NOT-
+ * SHARED, ADR-0004) so the exclusion is one rule everywhere, not three
+ * mechanisms: the dev tools (/swagger, /__dev), the feedback widget
+ * (/__feedback), and the built-in AI/RAG service probes (/ai, /rag, /vision,
+ * /embed, /image). This is the ONE thing standing between `/__feedback/*`
+ * (genuinely registered into the router by DevAdmin.register -> feedback.ts)
+ * and the public document now that generate() reads the LIVE route table per
+ * request (SWAG-NODE-FEEDBACK-LEAK) — before this list carried only
+ * /swagger + /__dev, so `/__feedback` was excluded only by BOOT ORDERING
+ * (swagger's route snapshot predated DevAdmin.register), not by a rule.
+ */
+const INTERNAL_PREFIXES = ["/swagger", "/__dev", "/__feedback", "/ai", "/rag", "/vision", "/embed", "/image"];
+
 // ── Configuration registries (v3.13.42) ───────────────────────────
 // Process-wide registries for security schemes and reusable component schemas
 // declared programmatically (addSecurityScheme / addSchema). Kept module-level so
@@ -365,12 +380,12 @@ function routeRequiresAuth(route: RouteDefinition, method: string): boolean {
 }
 
 /**
- * Path-filter a raw route pattern. Framework internals (/swagger, /__dev) are
- * ALWAYS excluded; then TINA4_SWAGGER_INCLUDE (allow-list) / _EXCLUDE apply.
- * Mirrors Python's _included.
+ * Path-filter a raw route pattern. Framework internals (INTERNAL_PREFIXES)
+ * are ALWAYS excluded; then TINA4_SWAGGER_INCLUDE (allow-list) / _EXCLUDE
+ * apply. Mirrors the other three frameworks' _included/included?.
  */
 function isIncludedPath(rawPath: string, include: string[], exclude: string[]): boolean {
-  for (const internal of ["/swagger", "/__dev"]) {
+  for (const internal of INTERNAL_PREFIXES) {
     if (rawPath === internal || rawPath.startsWith(internal + "/")) return false;
   }
   if (include.length > 0 && !include.some((p) => rawPath === p || rawPath.startsWith(p))) {

package/packages/swagger/src/ui.ts

@@ -1,11 +1,13 @@
 import type { Tina4Request, Tina4Response, RouteDefinition } from "../../core/src/index.js";
 
 // The UI assets load from a CDN by default (a documented architecture decision —
-// we don't vendor ~1.4MB of swagger-ui-dist, to stay small). Air-gapped
-// deployments point TINA4_SWAGGER_UI_CDN at a self-hosted mirror (a base URL
-// serving swagger-ui.css + swagger-ui-bundle.js).
+// we don't vendor ~1.4MB of swagger-ui-dist, to stay small). jsdelivr
+// (SWAG-CDN-NO-SRI, ADR-0004) — the SAME default as the Python and Ruby
+// masters, so all four frameworks pull the UI bundle from one CDN rather than
+// splitting jsdelivr/unpkg. Air-gapped deployments point TINA4_SWAGGER_UI_CDN
+// at a self-hosted mirror (a base URL serving swagger-ui.css + swagger-ui-bundle.js).
 function swaggerUiCdn(): string {
-  return (process.env.TINA4_SWAGGER_UI_CDN ?? "https://unpkg.com/swagger-ui-dist@5").replace(/\/+$/, "");
+  return (process.env.TINA4_SWAGGER_UI_CDN ?? "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5").replace(/\/+$/, "");
 }
 
 const SWAGGER_UI_HTML = (specUrl: string) => `<!DOCTYPE html>

package/types/cli/src/bin.d.ts

@@ -1,25 +1,3 @@
-/**
- * Kill any process listening on `port`. Returns true if anything was killed.
- *
- * Every PID is validated first. `parseInt` on a non-numeric lsof field yields
- * 1, and SIGTERM to PID 1 is the container's own init -- which is exactly how a
- * production container logged "Killed existing process on port 7148 (PID: 1
- * ...)" and then exited 143, killing itself on startup.
- */
-/**
- * The PIDs from `lsof -ti` output that are safe to signal.
- *
- * Pure so the safety rule can be tested directly. An unvalidated parse is a
- * footgun with real teeth: where lsof prints a different shape than -ti
- * implies, a non-numeric field becomes 0, and signalling PID 0 hits EVERY
- * process in the caller's own process group -- the server kills itself. That
- * is what produced "Killed existing process on port 7148 (PID: 1 ...)" in a
- * real image, where the container then exited 143.
- *
- * Accepts only all-digit tokens; never PID 0 (our group), PID 1 (init),
- * ourselves, or our own process group.
- */
-export declare function selectablePids(lsofOutput: string, me: number, myGroup?: number): number[];
 export interface CommandManifestEntry {
     name: string;
     summary: string;

package/types/core/src/api.d.ts

@@ -211,10 +211,17 @@ export declare class Api {
     download(path: string, destPath: string, params?: Record<string, string>): Promise<DownloadResult>;
     private buildUrl;
     /**
-     * Build the request headers (auth + cookie jar + extras) and serialize the
-     * body to a Buffer. Shared by every verb, upload, and download so the wire
-     * shape is identical and the transport seam sees exactly what the network
-     * path would.
+     * Build the request headers (default User-Agent + auth + cookie jar +
+     * extras) and serialize the body to a Buffer. Shared by every verb,
+     * upload, and download so the wire shape is identical and the transport
+     * seam sees exactly what the network path would.
+     *
+     * VERSION-DEC-03 (feature 130): every outbound request carries a default
+     * `Tina4/<version>` User-Agent. `this.headers` is spread AFTER the
+     * default, and `extraHeaders` after that, so a caller-supplied
+     * `User-Agent` (via the constructor's `headers` option, `addHeaders()`,
+     * or a per-call `extraHeaders`) always wins -- this is a default, never a
+     * clobber.
      */
     private buildRequest;
     /**

package/types/core/src/background.d.ts

@@ -19,10 +19,13 @@
  *
  * @param callback         Function to call (sync or async, no arguments).
  * @param intervalSeconds  Seconds between invocations (default: 1).
- * @returns A handle whose `stop()` clears just this one task.
+ * @returns A handle whose `stop()` clears just this one task and returns whether
+ *          it removed a live task (true) or was already stopped (false). This is
+ *          the ONE background surface — a stop-handle plus a count — shared with
+ *          Python/PHP/Ruby (`handle.stop()` -> bool, `backgroundTaskCount()`).
  */
 export declare function background(callback: () => unknown | Promise<unknown>, intervalSeconds?: number): {
-    stop: () => void;
+    stop: () => boolean;
 };
 /**
  * Clear every registered background task. Called by the server's graceful

package/types/core/src/devAdmin.d.ts

@@ -9,6 +9,41 @@
  *   - System info (Node.js version, V8, memory, uptime, platform)
  */
 import type { Router } from "./router.js";
+import type { Tina4Request } from "./types.js";
+/** Safe HTTP methods that never carry a state change — they skip the write gate. */
+export declare const DEV_SAFE_METHODS: Set<string>;
+/**
+ * Fail-closed same-origin check for a dev-admin mutation (DEVADMIN-DEC-01).
+ *
+ * A drive-by CSRF is a BROWSER cross-origin request, and a modern browser always
+ * sends `Sec-Fetch-Site` (and any browser sends `Origin` on a cross-origin POST):
+ *   - Sec-Fetch-Site present -> trust the browser's classification
+ *     (cross-site refused; same-origin / same-site / none ok).
+ *   - else Origin present -> require its host to match the request Host.
+ *   - else neither header -> not a browser cross-origin request (curl, a test
+ *     client, a server-side caller); it cannot be a drive-by, so allow here and
+ *     let the loopback gate still constrain the peer.
+ */
+export declare function devSameOriginOk(req: Tina4Request): boolean;
+/**
+ * Return `{status, error}` to REFUSE a dev-admin write, or `null` to allow.
+ *
+ * Two independent fail-closed gates on every /__dev mutation:
+ *   DEVADMIN-DEC-01  same-origin (all writes, incl. mcp/call) - drive-by CSRF.
+ *   DEVADMIN-DEC-02  loopback peer (all writes EXCEPT the MCP surface, which
+ *                    carries its own gate) - a network-exposed debug box.
+ * Reads the RAW socket peer (never X-Forwarded-For), exactly like the MCP gate.
+ */
+export declare function devMutationDenial(req: Tina4Request): {
+    status: number;
+    error: string;
+} | null;
+/**
+ * True when `rel` names secret material the file endpoints must never serve
+ * (DEVADMIN-DEC-03): `.env` / `.env.*` (the `.env.example` template is allowed),
+ * anything under `.git/` or `secrets/`, and private-key material.
+ */
+export declare function isSecretPath(rel: string): boolean;
 interface LogEntry {
     id: string;
     timestamp: string;

package/types/core/src/dispatchPipeline.d.ts

@@ -34,7 +34,7 @@ import type { Tina4Request } from "./types.js";
  * The prologue, in order. Exported as DATA so the pipeline can be asserted and
  * compared across frameworks without reading an implementation.
  */
-export declare const PROLOGUE_STAGES: readonly ["resetRequestCaches", "headStripIntercept", "sessionAutoStart"];
+export declare const PROLOGUE_STAGES: readonly ["resetRequestCaches", "headStripIntercept", "compressionEtagIntercept", "sessionAutoStart"];
 /**
  * After the prologue, before a route is looked up.
  *
@@ -98,6 +98,46 @@ export declare function resetRequestCaches(): Promise<void>;
  * @param rawRes Node's server response, whose write/end are replaced in place
  */
 export declare function headStripIntercept(rawReq: IncomingMessage, rawRes: ServerResponse): void;
+/**
+ * Gzip-compress + attach an ETag, and answer a matching conditional GET with
+ * a 304 that PRESERVES whichever validators the 200 would have carried
+ * (feature 40, CE-DEC-01/02). Mirrors the Python master's `build_headers()` +
+ * `app()` dispatch — the ONE header-builder step every DYNAMIC response
+ * funnels through.
+ *
+ * Node has no single "build the response, then send it" object the way
+ * Python/PHP/Ruby do — every response.ts method (json/html/text/xml/send/
+ * file/render) calls `res.end()` directly. So this intercepts `write`/`end`
+ * on the raw `ServerResponse` and buffers the body until `end()` is finally
+ * called, which is the only point a COMPLETE body — and therefore a
+ * Content-Length, a gzip candidate, and an ETag — exists to compute.
+ *
+ * BYPASS: a response that has ALREADY sent its headers by the time
+ * write()/end() is first called here (checked via `rawRes.headersSent`) is a
+ * streaming response — `response.ts`'s `stream()` calls `res.raw.writeHead()`
+ * up front, before any chunk — and is passed straight through unbuffered,
+ * exactly like Python's "streaming responses bypass ETag/compression".
+ *
+ * Installed in the PROLOGUE, right after `headStripIntercept`: since the LAST
+ * installed wrapper runs FIRST when `end()` is finally called, and
+ * `wrapResponseEnd` (dev-toolbar/feedback injection) installs LATER (in the
+ * REQUEST stage), the real execution order at send time is
+ * injection -> this -> `headStripIntercept` -> the true Node `res.end()` — so
+ * a HEAD response's preserved Content-Length reflects the (possibly
+ * compressed) body the equivalent GET would have sent, and the injected
+ * bytes are included in the compressed body + ETag hash, matching Python's
+ * ordering exactly.
+ *
+ * A static-file response (`static.ts`) still funnels through this same
+ * intercepted `write`/`end` — it pins its own weak size+mtime ETag and (when
+ * eligible) compresses itself BEFORE calling `res.raw.end()`, so by the time
+ * this runs, its status is already 200-with-ETag-set (this never overwrites
+ * it) or already 304 (the `statusCode === 200` guard below leaves it alone).
+ *
+ * @param rawReq Node's incoming message, read for Accept-Encoding / If-None-Match / If-Modified-Since
+ * @param rawRes Node's server response, whose write/end are replaced in place
+ */
+export declare function compressionEtagIntercept(rawReq: IncomingMessage, rawRes: ServerResponse): void;
 /**
  * Auto-start the session: read the cookie, create the session, then save it and
  * set the cookie when the response ends.

package/types/core/src/errorOverlay.d.ts

@@ -1,22 +1,26 @@
 /**
  * Tina4 Debug — Rich error overlay for development mode.
  *
- * Renders a professional, syntax-highlighted HTML error page when an unhandled
- * exception occurs in a route handler.
+ * Renders a rich HTML error page (exception type + message, the full stack with a
+ * seven-line source window per frame, request details, environment) when an unhandled
+ * exception reaches the server dispatch in development.
  *
- *   import { renderErrorOverlay, renderProductionError, isDebugMode } from "./errorOverlay.js";
+ *   import { renderErrorOverlay, isDebugMode } from "./errorOverlay.js";
  *
  *   try {
  *     await handler(req, res);
  *   } catch (err) {
- *     const html = isDebugMode()
- *       ? renderErrorOverlay(err as Error, req)
- *       : renderProductionError();
- *     res.html(html, 500);
+ *     if (isDebugMode()) res.html(renderErrorOverlay(err as Error, req), 500);
  *   }
  *
- * Only activate when TINA4_DEBUG is true.
- * In production, call renderProductionError() instead.
+ * Dev-only: the caller gates this on isDebugMode() (TINA4_DEBUG). The production 500 is
+ * NOT rendered here — the server dispatch renders errors/500.twig with an empty
+ * error_message (CWE-209), so the exception detail stays in the server log only.
+ *
+ * Sensitive request fields (Authorization / Cookie / Set-Cookie headers and
+ * password-like body/param keys) are redacted even in the dev overlay, the frame count
+ * is capped, and the caller wraps this render in a guard, so a broken overlay or a
+ * recursive stack still yields a bounded, safe 500.
  */
 /**
  * Render a rich HTML error overlay.
@@ -26,10 +30,6 @@
  * @returns Complete HTML page string.
  */
 export declare function renderErrorOverlay(error: Error, request?: any): string;
-/**
- * Render a safe, generic error page for production.
- */
-export declare function renderProductionError(statusCode?: number, message?: string, path?: string): string;
 /**
  * Check if TINA4_DEBUG is enabled.
  */

package/types/core/src/index.d.ts

@@ -5,14 +5,14 @@ export { Router, RouteGroup, RouteRef, WsRouteRef, defaultRouter, runRouteMiddle
 export { get, post, put, patch, del, any, websocket, del as delete } from "./router.js";
 export type { RouteInfo } from "./router.js";
 export { discoverRoutes } from "./routeDiscovery.js";
-export { MiddlewareChain, MiddlewareRunner, cors, requestLogger, CorsMiddleware, RateLimiterMiddleware, RequestLogger, SecurityHeadersMiddleware, CsrfMiddleware } from "./middleware.js";
+export { MiddlewareChain, MiddlewareRunner, cors, requestLogger, CorsMiddleware, RateLimiterMiddleware, RequestLogger, SecurityHeadersMiddleware, CsrfMiddleware, attachCsrfFromEnv } from "./middleware.js";
 export type { CorsConfig } from "./middleware.js";
-export { createRequest, makeCaseInsensitiveHeaders } from "./request.js";
-export { createResponse, errorResponse, setDefaultTemplatesDir, getFrond, setFrond, getFrameworkFrond } from "./response.js";
+export { createRequest, makeCaseInsensitiveHeaders, parseMultipart, saveUpload } from "./request.js";
+export { createResponse, errorResponse, setDefaultTemplatesDir, getFrond, setFrond, getFrameworkFrond, acceptPrefersJson, wantsJson, negotiatedErrorBody, } from "./response.js";
 export { tryServeStatic } from "./static.js";
 export { loadEnv, getEnv, requireEnv, hasEnv, allEnv, resetEnv, isTruthy } from "./dotenv.js";
 export { Env } from "./env.js";
-export { Log } from "./logger.js";
+export { Log, LogConfigurationError, LogArgumentError, LogWriteError } from "./logger.js";
 export { createHealthRoute, createHealthRoutes, healthPath } from "./health.js";
 export { rateLimiter } from "./rateLimiter.js";
 export { isTrustedProxy, trustedProxyNetworks, resolveClientIp, resetTrustedProxyCache } from "./trustedProxy.js";
@@ -52,7 +52,7 @@ export { DevMailbox } from "./devMailbox.js";
 export { WSDLService, WSDLOperation } from "./wsdl.js";
 export type { WSDLOperationMeta } from "./wsdl.js";
 export { HtmlElement, htmlElement, addHtmlHelpers, Raw, SafeString } from "./htmlElement.js";
-export { renderErrorOverlay, renderProductionError, isDebugMode } from "./errorOverlay.js";
+export { renderErrorOverlay, isDebugMode } from "./errorOverlay.js";
 export { AI_TOOLS, isInstalled, showMenu, installSelected, installAll, generateContext } from "./ai.js";
 export type { AiTool } from "./ai.js";
 export type { ImapMessage, ImapFullMessage, ImapAttachment } from "./messenger.js";
@@ -69,7 +69,7 @@ export { MongoSessionHandler } from "./sessionHandlers/mongoHandler.js";
 export type { MongoSessionConfig } from "./sessionHandlers/mongoHandler.js";
 export { ValkeySessionHandler } from "./sessionHandlers/valkeyHandler.js";
 export type { ValkeySessionConfig } from "./sessionHandlers/valkeyHandler.js";
-export { tests, assertEqual, assertRaises, assertTrue, assertFalse, runAll, reset } from "./testing.js";
+export { tests, expectEqual, expectRaises, expectTrue, expectFalse, runAll, reset } from "./testing.js";
 export { TestClient, TestResponse } from "./testClient.js";
 export { Tina4Test, AssertionError as Tina4AssertionError } from "./test.js";
 export type { TestRunResults } from "./test.js";
@@ -88,3 +88,6 @@ export type { FileEntry, FileRoute } from "./projectIndex.js";
 export { Docs } from "./docs.js";
 export type { DocsHit, ClassSpec, MethodSpec, IndexEntry, DriftHit } from "./docs.js";
 export { writeMcpDiscovery } from "./docsAutoDiscovery.js";
+export { takeOverPort, selectablePids, inContainer, isDev, noTakeoverOptedOut, writePidfile, readPidfile, removePidfile, pidfilePath, runtimeDir, TAKEOVER_NOTHING, TAKEOVER_KILLED, TAKEOVER_REFUSED_FOREIGN, TAKEOVER_REFUSED_OPTOUT, TAKEOVER_REFUSED_PROD, TAKEOVER_SKIPPED_CONTAINER, TAKEOVER_REFUSALS, } from "./portTakeover.js";
+export type { TakeoverResult } from "./portTakeover.js";
+export { resolveFrameworkVersion, TINA4_VERSION } from "./version.js";