tina4-nodejs 3.13.137 → 3.13.139

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

@@ -105,7 +105,6 @@ export declare class Messenger {
     private fromAddress;
     private fromName;
     private encryption;
-    private useTls;
     /** Whether an SMTP host was actually configured (see the constructor). */
     private smtpConfigured;
     /** The local mailbox, present only when this messenger captures. */
@@ -116,6 +115,13 @@ export declare class Messenger {
     private imapPass;
     private imapEncryption;
     constructor(options?: MessengerOptions);
+    /**
+     * How the SMTP connection is secured (ADR-0071 section 1). Port 465 is the
+     * implicit-TLS submission port whatever the setting; `ssl` is implicit TLS on
+     * any port; `tls` / `starttls` upgrade with a required STARTTLS; `none` is
+     * plaintext on purpose.
+     */
+    private smtpTransport;
     /**
      * Read-only IMAP encryption mode for inspection / tests.
      * Returns one of "tls", "starttls", "none", "ssl".
@@ -142,6 +148,11 @@ export declare class Messenger {
     private prepareRecipients;
     private connectSmtpSocket;
     private requireSmtpResponse;
+    /**
+     * Connect, read the greeting, EHLO, and - for the STARTTLS transport - upgrade.
+     * STARTTLS is REQUIRED: when the server does not offer it the session fails
+     * here, before AUTH or MAIL FROM is ever sent.
+     */
     private openSmtpSession;
     private authenticateSmtp;
     private sendSmtpEnvelope;

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

@@ -3,4 +3,6 @@ export declare class MetricsEngineError extends Error {
 }
 export declare function enginePath(): string | null;
 export declare function fullAnalysis(root?: string): Record<string, any>;
+/** The root the last full scan covered ("" before any scan). */
+export declare function metricsScanRoot(): string;
 export declare function fileDetail(filePath: string): Record<string, any>;

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

@@ -164,6 +164,8 @@ export interface CorsConfig {
 }
 /** Reset the CORS warn-once ledger. Test seam. */
 export declare function resetCorsWarnings(): void;
+/** The reasons warned about so far in this process (bounded by construction). */
+export declare function corsWarningReasons(): string[];
 /**
  * The resolved CORS policy — ONE implementation of the rules.
  *
@@ -210,9 +212,35 @@ export declare class CorsPolicy {
     /**
      * The CORS headers for a request origin. `isPreflight` adds Max-Age, which
      * the Fetch Standard only defines for a preflight response.
+     *
+     * `sameOrigin` (see isSameOriginRequest) marks a request whose Origin is the
+     * request's OWN origin. Browsers send Origin on every same-origin POST/PUT/
+     * PATCH/DELETE, and such a request needs no CORS headers at all, so it is not
+     * a CORS event: it is never warned about (tina4-python#139). It is handled by
+     * the configured policy exactly like any other request - the flag silences a
+     * warning and never grants anything, so a spoofed Host gains nothing.
+     *
+     * A warning never advises '*': it names the one origin the operator could add.
      */
-    headersFor(requestOrigin: string, isPreflight: boolean): Record<string, string>;
+    headersFor(requestOrigin: string, isPreflight: boolean, sameOrigin?: boolean): Record<string, string>;
 }
+/**
+ * Is the request SAME-origin: does its Origin equal the request's own origin?
+ *
+ * The own origin is the request's scheme (first hop of X-Forwarded-Proto, else
+ * the native TLS socket) and host (first hop of X-Forwarded-Host, else Host).
+ * Both sides go through the WHATWG URL parser, so scheme and host compare
+ * case-insensitively and http:80 / https:443 equal the port-less form. An
+ * unparseable Origin (including the opaque "null") is never same-origin.
+ *
+ * Proxy headers are honoured without a trusted-proxy check on purpose: the
+ * answer only decides whether a CORS WARNING is logged, never what the policy
+ * grants, so a forged header gains the sender nothing.
+ */
+export declare function isSameOriginRequest(req: {
+    headers: Record<string, string | string[] | undefined>;
+    socket?: unknown;
+}): boolean;
 /**
  * Built-in CORS middleware (function form).
  *
@@ -302,6 +330,22 @@ export declare class RequestLogger {
  *   Router.use(SecurityHeadersMiddleware);
  */
 export declare class SecurityHeadersMiddleware {
+    /**
+     * Run BEFORE route matching (ADR-0012), so EVERY response gets the headers,
+     * not only a matched route's. Static files, the SPA index.html at "/",
+     * template pages, 404s and 405s are all answered by the not-found fallback
+     * chain, which only the pre-match pass reaches. As a post-match middleware
+     * this left an SPA's front door with no CSP and frameable (tina4-python#137).
+     * The headers read no route metadata, so nothing is lost by running early.
+     */
+    static preMatch: boolean;
+    /**
+     * The canonical security header set (SECHDR-DEC-01) with its environment
+     * overrides, WITHOUT Strict-Transport-Security, which depends on the
+     * request's scheme. Also what a transport rejection carries (ADR-0068
+     * section 4), written before the scheme is known.
+     */
+    static canonicalHeaders(): Record<string, string>;
     static beforeSecurity(req: Tina4Request, res: Tina4Response): [Tina4Request, Tina4Response];
     /** Warn-once ledger for the default-CSP heads-up (per process). */
     private static cspDefaultWarned;

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

@@ -1,36 +1,3 @@
-/**
- * Zero-dependency MQTT 3.1.1 client — the protocol every broker and every IoT
- * device already speaks.
- *
- * Built on Node's `node:net` and `node:tls` stdlib modules only: no npm package,
- * so an app that talks to Mosquitto / EMQX / HiveMQ / AWS IoT adds nothing to its
- * dependency tree. Shaped like the Queue on purpose — publish / subscribe /
- * consume:
- *
- *     import { Mqtt } from "@tina4stack/tina4-node";
- *
- *     const mqtt = new Mqtt({ url: "mqtt://broker:1883" });   // TINA4_MQTT_URL
- *     await mqtt.connect();
- *     await mqtt.publish("fleet/meter-42/telemetry", '{"kwh":12.5}', 1);
- *
- *     for await (const message of mqtt.consume("fleet/+/telemetry", 1)) {
- *       if (message.isDuplicate()) continue;                  // QoS 1 is at-least-once
- *       store(message.topic, message.payload);
- *     }
- *
- * Environment: TINA4_MQTT_URL (default mqtt://127.0.0.1:1883),
- * TINA4_MQTT_CLIENT_ID, TINA4_MQTT_KEEPALIVE (seconds, default 60),
- * TINA4_MQTT_CA_FILE, TINA4_MQTT_TLS_VERIFY.
- *
- * Node has no synchronous blocking socket read, so connect()/publish()/
- * subscribe()/receive() are async and consume() is an async generator — the same
- * idiom as the Queue. No background task runs by default; opt in to the
- * cooperative keepalive with startKeepalive(), which registers a background()
- * task exactly like the queue consumers do.
- *
- * Single reader: like every MQTT client the socket has ONE network reader. Call
- * receive()/consume() from one place.
- */
 import { MqttMessage } from "./mqttMessage.js";
 /** Any MQTT protocol / connection failure. */
 export declare class MqttError extends Error {

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

@@ -0,0 +1,25 @@
+/**
+ * Optional peer packages: the database drivers and service clients an
+ * APPLICATION installs, never the framework (ADR-0067).
+ *
+ * tina4-nodejs installs as exactly one package. `pg`, `mongodb`, `redis` and
+ * the `@aws-sdk` S3 client are optional peerDependencies, which npm does not
+ * install, so for most apps "missing" is the normal state. Every feature that
+ * reaches for one must therefore fail at the point of use with the exact
+ * command that fixes it - never a bare MODULE_NOT_FOUND, never a silent no-op.
+ */
+/** The actionable "install it" error, one wording for every optional peer. */
+export declare function optionalPackageMissing(feature: string, packageNames: string[]): Error;
+/**
+ * Resolve an optional peer from the FRAMEWORK's location and return its module
+ * URL, or throw the actionable error. Synchronous, so a constructor can refuse
+ * immediately (parity with the Python master, which raises ImportError in the
+ * constructor) instead of leaving a rejected promise for later.
+ *
+ * Resolving from here rather than from process.cwd() is what finds the peer an
+ * app installed, wherever the server was started from.
+ *
+ * @param installTogether packages the feature needs as a set (S3 needs the
+ *   client AND the presigner), all named in the one install command.
+ */
+export declare function resolveOptionalPackage(packageName: string, feature: string, installTogether?: string[]): string;

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

@@ -1,13 +1,3 @@
-/**
- * Project plan management — persistent, human-readable task state.
- *
- * Ported from tina4_python/dev_admin/plan.py (master reference).
- * A plan is a markdown file under plan/ at the project root with sections
- * for title, goal, steps (checkboxes), and notes. Exactly one plan is
- * "current" at a time, recorded in plan/.current.
- *
- * Byte-for-byte compatible with Python's plan/*.md storage.
- */
 export interface PlanStep {
     text: string;
     done: boolean;

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

@@ -1,13 +1,3 @@
-/**
- * Project index — lightweight, persistent "where is what" map.
- *
- * Ported from tina4_python/dev_admin/project_index.py (master reference).
- *
- * Storage: .tina4/project_index.json at the project root.
- * Freshness: lazy-refreshes on read via mtime compare — no watchers.
- * Extractors: per-language symbol extraction (TS/JS, Twig/HTML, SQL, Markdown,
- * Python) using regex. No LLM involvement — pure static analysis.
- */
 export interface FileRoute {
     method: string;
     path: string;

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

@@ -11,6 +11,11 @@ export interface PushOptions {
     privateKey?: string;
     ttl?: number;
     urgency?: "very-low" | "low" | "normal" | "high";
+    /**
+     * SSRF guard (ADR-0084): an explicit allow-list of hosts / host:port / CIDRs
+     * that bypass the private-endpoint refusal even with the opt-out off.
+     */
+    allowHosts?: string[];
 }
 export interface PushResult {
     ok: boolean;

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

@@ -59,7 +59,7 @@ export interface ConsumeOptions {
 export interface QueueBackendInterface {
     push(queue: string, payload: unknown, delay?: number, priority?: number): string;
     pop(queue: string): QueueJob | null;
-    size(queue: string): number;
+    size(queue: string, status?: string): number;
     clear(queue: string): void;
     /**
      * Release whatever connection the backend holds, and be safe to call twice.
@@ -74,6 +74,7 @@ export interface QueueBackendInterface {
     close(): void;
     complete?(queue: string, id: string): void;
     fail?(queue: string, id: string, error: string, maxRetries: number, retryBackoff: number): void;
+    reject?(queue: string, id: string, reason: string, maxRetries: number): void;
     /**
      * Explicit manual re-queue: returns true if the id was found and revived,
      * false otherwise (parity with Python's backend.retry_job()). A backend may
@@ -289,6 +290,11 @@ export declare class Queue {
      * after retryBackoff seconds) or dead-letter (attempts >= maxRetries).
      */
     _failJob(queue: string, job: QueueJob, error: string, maxRetries: number): void;
+    /**
+     * Dead-letter a job immediately — no retry (ADR-0023 reject()). Distinct from
+     * _failJob, which retries until maxRetries is spent.
+     */
+    _rejectJob(queue: string, job: QueueJob, reason: string, maxRetries: number): void;
     /**
      * Re-queue a job back to the main queue directory with incremented attempts.
      */

package/types/core/src/queueBackends/liteBackend.d.ts

@@ -130,5 +130,14 @@ export declare class LiteBackend {
      * dead-letter file -- two spellings of the same intent that previously
      * diverged.
      */
+    /**
+     * Reject a job permanently — dead-letter it NOW, no retry (ADR-0023).
+     *
+     * Unlike failJob(), which requeues until maxRetries is spent, rejectJob()
+     * moves a known-poison job straight to the dead-letter store. attempts is
+     * floored at maxRetries so deadLetters() (attempts >= maxRetries) returns it
+     * and size("dead") agrees.
+     */
+    rejectJob(queue: string, job: QueueJob, reason: string, maxRetries: number): void;
     retryJob(queue: string, job: QueueJob, delaySeconds?: number): void;
 }

package/types/core/src/queueBackends/mongoBackend.d.ts

@@ -42,6 +42,8 @@ export declare class MongoBackend implements QueueBackend {
     private collection;
     private visibilityTimeout;
     private maxRetries;
+    /** Module URL of the app-installed `mongodb` driver, resolved once. */
+    private driverUrl;
     constructor(config?: MongoConfig);
     /**
      * Resolved connection config — exposed for testing/introspection.
@@ -74,7 +76,14 @@ export declare class MongoBackend implements QueueBackend {
     popById(queue: string, id: string): QueueJob | null;
     push(queue: string, payload: unknown, delay?: number, priority?: number): string;
     pop(queue: string): QueueJob | null;
-    size(queue: string): number;
+    size(queue: string, status?: string): number;
+    /**
+     * Dead-letter a job immediately — no retry (ADR-0023 reject()). Distinct from
+     * fail(): fail() requeues until maxRetries is spent. attempts is floored at
+     * maxRetries so deadLetters()/size("dead") (which filter/scope to the
+     * dead-letter store) see it.
+     */
+    reject(queue: string, id: string, reason: string, maxRetries: number): void;
     clear(queue: string): void;
     /**
      * Acknowledge a completed job — drop its reservation so the reclaim never

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

@@ -11,6 +11,18 @@ import type { Tina4Request, UploadedFile } from "./types.js";
  */
 export declare function makeCaseInsensitiveHeaders(raw: IncomingHttpHeaders): IncomingHttpHeaders;
 export declare function createRequest(req: IncomingMessage): Tina4Request;
+export declare const DEFAULT_MAX_UPLOAD_SIZE = 10485760;
+/**
+ * Read a numeric limit from the environment. A value that is not a usable
+ * number falls back to the default with a warning naming the variable (the
+ * same rule as PHP's Server::resolveLimit) - a typo must never be what
+ * disables a DoS guard.
+ */
+export declare function resolveLimit(name: string, fallback: number, zeroAllowed?: boolean): number;
+/** TINA4_MAX_UPLOAD_SIZE, read when it is needed so a value from .env counts. */
+export declare function maxUploadSize(): number;
+/** The one 413 wording (ADR-0068 section 4). */
+export declare function bodyTooLargeMessage(bytes: number | bigint | string, limit: number): string;
 export declare class PayloadTooLargeError extends Error {
     statusCode: number;
     constructor(actual: number, limit: number);

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

@@ -1,5 +1,18 @@
 import type { ServerResponse } from "node:http";
 import type { Tina4Response } from "./types.js";
+/**
+ * The caller's name as a JSON string literal with non-ASCII escaped, byte-
+ * identical to Python's json.dumps (ADR-0068), so a name that is itself broken
+ * cannot break the error message or the log line carrying it.
+ */
+export declare function quoteHeaderName(name: string): string;
+/**
+ * Refuse a response header whose name is not an HTTP token or whose value
+ * carries CR, LF or NUL, with the exact ADR-0068 wording. node:http refuses
+ * these too, but names a broken header raw (a CR/LF in the name reaches the
+ * log line) - this is the ADR's form, checked first.
+ */
+export declare function assertSafeHeader(name: string, value: unknown): void;
 /**
  * Set the default templates directory for render().
  * Called by server.ts during startup.

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

@@ -88,6 +88,25 @@ export declare function _checkLegacyEnvVars(): void;
  * of killing an innocent process.
  */
 export declare function killPort(port: number): void;
+/**
+ * Variables that mark a CI run, in ADR-0070's order (ci_env_vars). A run is CI
+ * when any of them holds a value that, trimmed and lower-cased, is non-empty
+ * and not in CI_NOT_SET_VALUES.
+ */
+export declare const CI_ENVIRONMENT_VARIABLES: string[];
+/** Values that say "not under CI" (ADR-0070 ci_not_set_values), compared trimmed and lower-cased. */
+export declare const CI_NOT_SET_VALUES: string[];
+/**
+ * Whether the server may open a browser (ADR-0070): only for a developer at a
+ * desk. Every rule is a veto; nothing forces a browser open past one.
+ *
+ *   1. development only - the caller's resolved debug mode, and never with
+ *      TINA4_PRODUCTION truthy or in a cluster worker (the primary decides);
+ *   2. never when TINA4_NO_BROWSER is truthy (true/1/yes/on);
+ *   3. never with --no-browser / a programmatic noBrowser (it can only veto);
+ *   4. never under CI.
+ */
+export declare function shouldOpenBrowser(isDevelopment: boolean, noBrowser?: boolean): boolean;
 /**
  * Resolve port and host with priority: explicit config > ENV var > default.
  * Exported for testability.

package/types/core/src/sessionHandlers/childError.d.ts

@@ -1,18 +1,3 @@
-/**
- * Tina4 session handlers — turn a failed `execFileSync` child into a readable cause.
- *
- * The session-handler interface is synchronous but every backend client is async,
- * so each command runs in a short-lived `node -e` child. When that child fails,
- * `execFileSync` throws an error whose `.message` begins "Command failed:" and
- * then embeds THE ENTIRE GENERATED SCRIPT — kilobytes of source with the real
- * reason nowhere in it. Every handler used to throw exactly that, so an
- * operator debugging a Redis outage got a wall of JavaScript instead of
- * "connect ECONNREFUSED 127.0.0.1:6379".
- *
- * The children already write the real reason to stderr; `execFileSync` captures
- * it on `err.stderr`. This module is the ONE place that prefers it, so the three
- * call sites (respClient, mongoClient, redisHandler's npm path) cannot drift.
- */
 /**
  * Extract the most useful one-line cause from a thrown `execFileSync` error.
  *

package/types/core/src/sessionHandlers/databaseHandler.d.ts

@@ -86,9 +86,33 @@ export declare class DatabaseSessionHandler implements SessionHandler {
     /** Run a statement that returns nothing. */
     private exec;
     /**
-     * Ensure the session table exists (called once on first use).
+     * Ensure the session table exists (called once on first use) - safely when
+     * several processes race to create it.
+     *
+     * Every per-engine statement above is check-then-act, so two processes can
+     * both find the table absent and both CREATE; the loser errors, and every
+     * engine spells that differently (a pg_type unique violation on PostgreSQL,
+     * Msg 2714 on SQL Server, an RDB$RELATIONS unique violation on Firebird). So
+     * a failure is judged by RE-CHECKING whether the table now exists, never by
+     * parsing the message - the rescue the Firebird note above has always
+     * assumed, and which was not here. MEASURED on the lab before it: six real
+     * processes racing lost one to five of them on PostgreSQL, SQLite and
+     * Firebird.
+     *
+     * The re-check is RETRIED because the loser can fail BEFORE the winner has
+     * committed. On MySQL, CREATE TABLE IF NOT EXISTS takes a shared metadata
+     * lock, checks, then upgrades it to exclusive; two upgrades deadlock, and when
+     * MySQL cannot back the victim off silently it answers 1213 "Deadlock found"
+     * while the winner's table is still invisible (tina4-php CI run 35972320442).
+     * Bounded, so a genuine failure (no CREATE grant) still throws. Same attempts
+     * and delays in all four frameworks.
      */
     private ensureTable;
+    /**
+     * Whether tina4_session exists, asked the one way every engine answers alike:
+     * a query against it that returns no rows succeeds only if it is there.
+     */
+    private tableExists;
     read(sessionId: string): SessionData | null;
     write(sessionId: string, data: SessionData, ttl: number): void;
     destroy(sessionId: string): void;

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

@@ -2,6 +2,7 @@ import type { Router } from "./router.js";
 export declare class SsoError extends Error {
 }
 type Json = Record<string, any>;
+export { liveSessionIdentity } from "./ssoIdentity.js";
 export interface SsoOptions {
     issuer?: string;
     clientId?: string;

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

@@ -0,0 +1,10 @@
+/**
+ * The stored SSO identity, only while it is live (ADR-0079 s5). `stored` is the
+ * reserved _tina4_sso session value. The identity needs an issuer and a
+ * subject, and a numeric expires_at that is 0 (the provider gave no lifetime)
+ * or still in the future.
+ *
+ * Its own dependency-free module, so the auth gate can use it without
+ * importing the OIDC client (and everything the client imports).
+ */
+export declare function liveSessionIdentity(stored: unknown): Record<string, any> | null;

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

@@ -0,0 +1,19 @@
+export declare const ALLOW_PRIVATE_ENV = "TINA4_ALLOW_PRIVATE_REQUESTS";
+/** Raised when the SSRF guard refuses an outbound request. */
+export declare class SsrfError extends Error {
+    constructor(message: string);
+}
+/** True when TINA4_ALLOW_PRIVATE_REQUESTS opts out of the guard. */
+export declare function allowPrivateRequests(): boolean;
+/**
+ * Classify one IP string: true = private/internal, refuse it. An IPv4-mapped
+ * IPv6 address is classified by its embedded IPv4. An unparseable value is
+ * treated as blocked - the guard refuses what it cannot classify.
+ */
+export declare function isBlockedAddress(ip: string): boolean;
+/**
+ * Refuse `url` when it targets a private/internal address. Throws SsrfError for a
+ * non-http(s) scheme, an unresolvable host, or any resolved address in the
+ * blocked space. `allowHosts` is a list of hosts / host:port / CIDRs to permit.
+ */
+export declare function guardUrl(url: string, allowHosts?: string[]): Promise<void>;

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

@@ -0,0 +1,28 @@
+import type { IncomingMessage, ServerResponse, Server } from "node:http";
+/**
+ * Answer through a ServerResponse with the rejection shape and close. Every
+ * header already on the response is dropped: the shape is exact. Node closes
+ * the connection once the answer is flushed (Connection: close), so the rest
+ * of a refused upload is never read.
+ */
+export declare function sendTransportRejection(res: ServerResponse, status: number, message: string, end?: {
+    (cb?: () => void): ServerResponse<IncomingMessage>;
+    (chunk: any, cb?: () => void): ServerResponse<IncomingMessage>;
+    (chunk: any, encoding: BufferEncoding, cb?: () => void): ServerResponse<IncomingMessage>;
+}): void;
+/**
+ * ADR-0068 section 2 for Node. node:http refuses an unsafe header where it is
+ * set (setHeader / appendHeader / writeHead). A header set straight on the raw
+ * response - past Tina4's own call-site check - used to surface as a route
+ * error page. Here the refusal is recorded instead, and whatever the handler
+ * sends next becomes the fixture's 500 {"error":"Invalid response header"},
+ * logged by header name. Tina4's own Response keeps refusing at the call site
+ * (its check runs before this layer is reached).
+ */
+export declare function guardUnsafeHeaders(res: ServerResponse): void;
+/**
+ * Create the HTTP server Tina4 listens with - the main port, its loopback
+ * siblings, the AI port and every cluster worker - so every one of them keeps
+ * the same limits and answers.
+ */
+export declare function createTina4HttpServer(handler: (req: IncomingMessage, res: ServerResponse) => unknown): Server;

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

@@ -1,19 +1,3 @@
-/**
- * Which upstream hops are allowed to speak for a client (ADR-0019).
- *
- * X-Forwarded-For is written by whoever sends it. Reading it unconditionally
- * lets any client choose its own rate-limit bucket, and - worse - choose
- * SOMEONE ELSE'S, which is a starvation primitive against a third party. So
- * the forwarding headers are believed only when the raw socket peer is a proxy
- * the operator has explicitly declared.
- *
- * Configured by TINA4_TRUSTED_PROXIES: comma-separated exact addresses and/or
- * CIDR ranges, IPv4 and IPv6, e.g. "10.0.0.0/8, 192.168.1.5, ::1, fd00::/8".
- * Empty or unset means trust NOTHING, which is the secure default.
- *
- * Zero-dependency: node: has no CIDR matcher, so the packing and prefix
- * comparison are done here over plain byte arrays.
- */
 /** [packed network address, prefix bits] */
 type Network = [Uint8Array, number];
 /**

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

@@ -198,6 +198,11 @@ export interface Tina4Config {
      *  and staticDir are resolved relative to this path instead of process.cwd(). */
     basePath?: string;
     routesDir?: string;
+    /**
+     * Never open a browser on start (ADR-0070 rule 3, the programmatic
+     * --no-browser). It can only veto: false does not force one open.
+     */
+    noBrowser?: boolean;
     modelsDir?: string;
     templatesDir?: string;
     staticDir?: string;

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

@@ -47,6 +47,7 @@ export declare class NATSBackplane implements WebSocketBackplane {
     private url;
     private subs;
     private ready;
+    private natsModuleUrl;
     constructor(url?: string);
     publish(channel: string, message: string): Promise<void>;
     subscribe(channel: string, callback: (message: string) => void): Promise<void>;

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

@@ -1,23 +1,3 @@
-/**
- * Tina4 WSDL/SOAP — SOAP 1.1 / WSDL 1.1 service base class.
- *
- * Auto-generates WSDL definitions and handles SOAP XML requests.
- * Zero external dependencies — uses simple string parsing for XML.
- *
- * Matches the PHP reference implementation (Tina4\WSDL).
- *
- *   import { WSDLService, WSDLOperation } from "@tina4/core";
- *
- *   class Calculator extends WSDLService {
- *     serviceName = "Calculator";
- *     serviceUrl = "/api/calculator";
- *
- *     @WSDLOperation({ output: { Result: "int" } })
- *     async Add(a: number, b: number): Promise<Record<string, unknown>> {
- *       return { Result: a + b };
- *     }
- *   }
- */
 export interface WSDLOperationMeta {
     name: string;
     description?: string;
@@ -34,8 +14,14 @@ interface WSDLOperationConfig {
  *
  *   @WSDLOperation({ description: "Add two numbers", input: { a: "int", b: "int" }, output: { Result: "int" } })
  *   async Add(a: number, b: number): Promise<Record<string, unknown>> { ... }
+ *
+ * Works under both decorator flavours: TC39 standard decorators (what tsx and
+ * esbuild compile by default: `(method, context)`) and TypeScript's
+ * experimentalDecorators (`(prototype, name, descriptor)`).
  */
-export declare function WSDLOperation(config?: WSDLOperationConfig): (_target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function WSDLOperation(config?: WSDLOperationConfig): (target: unknown, context: string | symbol | {
+    name: string | symbol;
+}, descriptor?: PropertyDescriptor) => PropertyDescriptor | undefined;
 export declare abstract class WSDLService {
     abstract serviceName: string;
     abstract serviceUrl: string;
@@ -72,7 +58,7 @@ export declare abstract class WSDLService {
     /**
      * Handle incoming SOAP request (parse XML, dispatch to method, return SOAP response).
      */
-    handle(soapXml?: string): Promise<string>;
+    handle(soapXml?: string | Uint8Array): Promise<string>;
     /**
      * Register this service's routes on a router.
      * GET /service-url?wsdl -> WSDL XML

package/types/frond/src/engine.d.ts

@@ -241,7 +241,13 @@ export declare class Frond {
      */
     private applyFastFilter;
     private applyRenderedFilter;
-    private variablePermitted;
+    /**
+     * Sandbox gate for a WHOLE expression (F6/ADR-0077): refuse a dunder walk or
+     * a root variable outside the allow-list. Applied to output, if conditions,
+     * set right-hand sides and for iterables so none can smuggle a blocked
+     * variable past the per-output gate.
+     */
+    private sandboxExprOk;
     private resolveConcatenation;
     private applyRenderedFilters;
     private evalVarInner;

package/types/orm/src/adapters/firebird.d.ts

@@ -98,6 +98,12 @@ export declare class FirebirdAdapter implements DatabaseAdapter {
     /** Connect to Firebird. Must be called before using the adapter. */
     /** ADR-0044 required adapter capability. */
     getDatabaseType(): string;
+    /**
+     * Quote a name the ORM emits the way Firebird stores it: UPPER CASE (see
+     * fbQuote). An already-quoted name passes through - the escape hatch for a
+     * genuinely case-sensitive table. Python master: FirebirdAdapter.quote_identifier.
+     */
+    quoteIdentifier(name: string): string;
     /** ADR-0044: readable/writable native boolean. */
     autocommit: boolean;
     /**
@@ -186,6 +192,12 @@ export declare class FirebirdAdapter implements DatabaseAdapter {
         lastId?: number | bigint;
     }>;
     executeAsync(sql: string, params?: unknown[]): Promise<unknown>;
+    /**
+     * Run a row-producing statement ONCE and return its rows, for
+     * Database.execute(). node-firebird's execute() returns no rows, so a SELECT
+     * or an `INSERT ... RETURNING` through execute() used to lose them.
+     */
+    executeRowsAsync<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
     query<T = Record<string, unknown>>(sql: string, params?: unknown[]): T[];
     queryAsync<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
     /**

package/types/orm/src/adapters/mssql.d.ts

@@ -45,8 +45,19 @@ export declare class MssqlAdapter implements DatabaseAdapter {
      * `startAt` lets a caller that has already consumed N placeholders (an UPDATE
      * whose SET values are @p0..@p{N-1}) continue the numbering into a raw WHERE
      * fragment instead of restarting at @p0.
+     *
+     * Only REAL placeholders are rewritten: a `?` inside a string literal, a
+     * quoted identifier or a comment is left alone (tina4-python#138).
      */
     private convertPlaceholders;
+    /**
+     * The SQL the driver receives. With NO parameters it is sent EXACTLY as
+     * written (the cross-framework contract): there is nothing to bind.
+     *
+     * tina4: with parameters every `?` outside a literal, quoted identifier or
+     * comment is a placeholder.
+     */
+    private bindable;
     execute(sql: string, params?: unknown[]): unknown;
     executeMany(sql: string, paramsList: unknown[][]): {
         totalAffected: number;

package/types/orm/src/adapters/mysql.d.ts

@@ -23,6 +23,8 @@ export declare class MysqlAdapter implements DatabaseAdapter {
     /** Connect to MySQL. Must be called before using the adapter. */
     /** ADR-0044 required adapter capability. */
     getDatabaseType(): string;
+    /** MySQL identifiers are backtick-quoted; a double-quoted token is a string. */
+    quoteIdentifier(name: string): string;
     /** ADR-0044: readable/writable native boolean. */
     autocommit: boolean;
     /**