tina4-nodejs 3.13.91 → 3.13.94

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

@@ -0,0 +1,75 @@
+/**
+ * Tina4 Events — Simple observer pattern for decoupled communication.
+ *
+ * Zero-dependency event system. Fire events, register listeners.
+ *
+ *   Events.on("user.created", (user) => console.log(`Welcome ${user.name}!`));
+ *   Events.emit("user.created", { name: "Alice", email: "alice@example.com" });
+ *
+ * One-time listeners:
+ *
+ *   Events.once("app.ready", () => console.log("App started!"));
+ */
+export declare class Events {
+    /**
+     * Register a listener for an event.
+     * Higher priority runs first.
+     */
+    static on(event: string, callback: (...args: unknown[]) => void, priority?: number): void;
+    /**
+     * Register a listener that fires only once then auto-removes.
+     */
+    static once(event: string, callback: (...args: unknown[]) => void, priority?: number): void;
+    /**
+     * Remove a specific listener, or all listeners for an event.
+     *
+     *   Events.off("user.created", handler)  // remove specific
+     *   Events.off("user.created")           // remove all for event
+     */
+    static off(event: string, callback?: (...args: unknown[]) => void): void;
+    /**
+     * Fire an event synchronously. Returns array of listener results.
+     *
+     * Listener isolation (E1): each listener call is wrapped — a listener
+     * that THROWS does NOT abort the rest of emit(). The error is LOGGED
+     * (never silent) and the failed listener contributes a `null` slot, so
+     * N listeners always yield N results in priority order; surviving
+     * listeners run regardless of an earlier throw.
+     *
+     * Pass `{ strict: true }` to RE-RAISE on the first listener error
+     * instead of isolating it (later listeners then do NOT run).
+     *
+     * once() cleanup stays correct under isolation: the one-shot listener is
+     * spliced out BEFORE its callback runs, so a throw never leaves it
+     * registered.
+     */
+    static emit(event: string, ...args: unknown[]): unknown[];
+    static emit(event: string, options: {
+        strict?: boolean;
+    }, ...args: unknown[]): unknown[];
+    /**
+     * Emit an event and await all async listeners.
+     * Returns array of resolved results from each listener.
+     *
+     * Listener isolation (E1): identical to emit() — each awaited listener
+     * is isolated; a rejection/throw is LOGGED and contributes a `null`
+     * slot without aborting the others. `{ strict: true }` re-raises on the
+     * first error.
+     */
+    static emitAsync(event: string, ...args: unknown[]): Promise<unknown[]>;
+    static emitAsync(event: string, options: {
+        strict?: boolean;
+    }, ...args: unknown[]): Promise<unknown[]>;
+    /**
+     * Get all listener callbacks for an event (in priority order).
+     */
+    static listeners(event: string): Array<(...args: unknown[]) => void>;
+    /**
+     * List all registered event names.
+     */
+    static events(): string[];
+    /**
+     * Remove all listeners for all events.
+     */
+    static clear(): void;
+}

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

@@ -0,0 +1,55 @@
+export declare class FakeData {
+    private rng;
+    private seeded;
+    constructor(seed?: number);
+    /** Static factory — create a seeded FakeData instance. */
+    static seed(seed: number): FakeData;
+    /** Returns a random integer in [min, max) using the instance PRNG. */
+    private randInt;
+    /** Pick a random element from an array. */
+    private pick;
+    firstName(): string;
+    lastName(): string;
+    name(): string;
+    email(): string;
+    phone(): string;
+    address(): string;
+    city(): string;
+    country(): string;
+    zipCode(): string;
+    company(): string;
+    jobTitle(): string;
+    paragraph(sentences?: number): string;
+    sentence(words?: number): string;
+    word(): string;
+    integer(min?: number, max?: number): number;
+    numeric(min?: number, max?: number, decimals?: number): number;
+    boolean(): boolean;
+    date(start?: string, end?: string): string;
+    uuid(): string;
+    url(): string;
+    ipAddress(): string;
+    colorHex(): string;
+    /** Returns fake test credit card numbers (Luhn-valid test patterns). */
+    creditCard(): string;
+    currency(): string;
+    /**
+     * Returns multi-paragraph text.
+     * Matches Python's text() method.
+     */
+    text(paragraphs?: number): string;
+    /**
+     * Returns a random element from the given array.
+     * Matches Python's choice() method.
+     */
+    choice<T>(items: T[]): T;
+    /**
+     * Run seed files from a directory. Each file should export a default async function.
+     * Returns an array of executed file paths.
+     */
+    seedDir(seedDir?: string): Promise<string[]>;
+    /**
+     * Run a generator function `count` times and return the results.
+     */
+    run(fn: () => Record<string, unknown>, count?: number): Record<string, unknown>[];
+}

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

@@ -0,0 +1,90 @@
+/**
+ * Customer feedback widget — Tier 4 port from tina4-python.
+ *
+ * End-users of a shipped Tina4 app give UX feedback via a floating bubble
+ * widget. Widget visibility + API are gated by TWO env flags:
+ *
+ *   - TINA4_ENABLE_FEEDBACK   master switch (explicit opt-in)
+ *   - TINA4_FEEDBACK_WHITELIST comma-separated emails / user IDs
+ *
+ * Architecture (mirrors Python `tina4_python/dev_admin/__init__.py`
+ * lines 1440-1645):
+ *
+ *   1. Framework middleware injects <script src="/__feedback/widget.js">
+ *      into HTML responses for whitelisted users only.
+ *   2. Widget POSTs to /__feedback/api/turn for each conversational turn.
+ *   3. That handler verifies whitelist + rate-limit, stamps the user
+ *      identity server-side (client cannot fake `sender`), then forwards
+ *      to the Rust agent's /feedback/intake.
+ *
+ * The widget is for END USERS of a shipped app — the /__dev paths get
+ * skipped so the dev admin's own chat bubble doesn't sit on top of the
+ * customer feedback bubble.
+ */
+import type { RouteHandler, Tina4Request } from "./types.js";
+import type { Router } from "./router.js";
+/**
+ * Master switch — both this AND a non-empty whitelist must be set for
+ * the widget to render or the API to accept submissions. Mirrors
+ * Python's `_feedback_enabled()`.
+ */
+export declare function feedbackEnabled(): boolean;
+/**
+ * Comma-separated emails / user IDs in env, lowercased + trimmed.
+ * Returns [] when the master switch is off so callers can short-circuit
+ * with a single check. Mirrors Python's `_feedback_whitelist()`.
+ */
+export declare function feedbackWhitelist(): string[];
+/**
+ * Best-effort user identity from JWT/Bearer auth. Falls back to
+ * TINA4_FEEDBACK_DEV_USER (local dev convenience — lets the framework
+ * owner test the widget without a full auth setup). Mirrors Python's
+ * `_feedback_identify_user()`.
+ */
+export declare function feedbackIdentifyUser(request: Tina4Request): string | null;
+/**
+ * Returns [allowed, userId]. Both halves are required — feature off when
+ * either is falsy. Mirrors Python's `_feedback_is_whitelisted()`.
+ */
+export declare function feedbackIsWhitelisted(request: Tina4Request): [boolean, string | null];
+/**
+ * 5 turns/hour per user, sliding window. Prunes old timestamps lazily on
+ * every call (no background task needed). Mirrors Python's
+ * `_feedback_rate_limit_ok()`.
+ */
+export declare function feedbackRateLimitOk(user: string): boolean;
+/** Test-only: clear rate-limit state between cases. Not part of public API. */
+export declare function _resetFeedbackRateLimit(): void;
+/**
+ * Insert the widget <script> into HTML for whitelisted users. Called
+ * from the response pipeline right before the body is flushed. No-op if:
+ *   - request path starts with /__dev or /__feedback (developer
+ *     pages have their own chat trigger)
+ *   - master switch / whitelist not set
+ *   - user not in whitelist
+ *   - html lacks </body>
+ * Idempotent — looks for the `data-tina4-feedback` marker and bails.
+ * Mirrors Python's `inject_feedback_widget()`.
+ */
+export declare function injectFeedbackWidget(request: Tina4Request, html: string): string;
+/**
+ * POST /__feedback/api/turn — proxy one conversational turn to the Rust
+ * agent's `/feedback/intake`. Server stamps `sender` from the verified
+ * identity so the client cannot inject who they are. Mirrors Python's
+ * `_api_feedback_turn()`.
+ */
+export declare const handleFeedbackTurn: RouteHandler;
+declare const WIDGET_BUNDLE_PATH: string;
+/**
+ * GET /__feedback/widget.js — serve the widget bundle with no-cache
+ * headers so a broken bundle doesn't get stuck in browser caches.
+ * Mirrors Python's `_api_feedback_widget_js()`.
+ */
+export declare const handleFeedbackWidgetJs: RouteHandler;
+/**
+ * Register the two feedback routes on a Router. Called from the dev
+ * admin setup so the routes only exist when the dev surface is
+ * enabled — production deployments without TINA4_DEBUG also skip them.
+ */
+export declare function registerFeedbackRoutes(router: Router): void;
+export { WIDGET_BUNDLE_PATH };

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

@@ -0,0 +1,207 @@
+/**
+ * Tina4 GraphQL — Zero-dependency GraphQL engine.
+ *
+ * Recursive-descent parser, schema builder, and query executor.
+ *
+ *   import { GraphQL } from "@tina4/core";
+ *
+ *   const gql = new GraphQL();
+ *   gql.addType("User", { id: { type: "ID" }, name: { type: "String" } });
+ *   gql.addQuery("user", { id: "ID!" }, "User", (root, args) => getUser(args.id));
+ *   const result = gql.execute('{ user(id: "1") { name } }');
+ *
+ * Supported:
+ *   - Queries, mutations
+ *   - Variables, default values
+ *   - Aliases
+ *   - Nested selections
+ *   - List types ([Type])
+ *   - Non-null types (Type!)
+ *   - Error capture (resolver exceptions become GraphQL errors)
+ */
+export interface GraphQLField {
+    type: string;
+    description?: string;
+}
+export type ResolverFn = (root: unknown, args: Record<string, unknown>, context?: Record<string, unknown>) => unknown;
+export interface GraphQLResult {
+    data: Record<string, unknown> | null;
+    errors?: Array<{
+        message: string;
+        path?: string[];
+    }>;
+}
+interface Token {
+    type: string;
+    value: string;
+    pos: number;
+}
+export declare function tokenize(source: string): Token[];
+export declare class ParseError extends Error {
+    constructor(message: string);
+}
+/**
+ * URL the GraphQL handler should be mounted at.
+ * `TINA4_GRAPHQL_ENDPOINT` overrides the default `/graphql`.
+ */
+export declare function graphqlEndpoint(): string;
+/**
+ * Whether to auto-generate the schema from registered ORM models.
+ * `TINA4_GRAPHQL_AUTO_SCHEMA=true` (default) lets the dev server build a
+ * usable schema with no manual wiring; set to `false` to require explicit
+ * `addType` / `addQuery` calls.
+ */
+export declare function graphqlAutoSchemaEnabled(): boolean;
+/**
+ * Maximum selection-set nesting depth. A deeply nested query (or a circular
+ * fragment) would otherwise recurse without bound — a classic GraphQL DoS /
+ * stack-overflow vector. `TINA4_GRAPHQL_MAX_DEPTH` overrides the default (50);
+ * set `<= 0` to disable the guard. A non-numeric value falls back to 50.
+ */
+export declare function graphqlMaxDepth(): number;
+export declare class GraphQL {
+    private types;
+    private queries;
+    private mutations;
+    /** Object-type field resolvers indexed by `[typeName][fieldName]`. */
+    private fieldResolvers;
+    private static classResolvers;
+    private static defaultInstance;
+    /**
+     * Maximum selection-set nesting depth (read from `TINA4_GRAPHQL_MAX_DEPTH`,
+     * default 50; `<= 0` disables the guard). Public so tests can set it and the
+     * dev app can introspect it. Counted per selection level AND per fragment
+     * spread / inline fragment, so circular fragments are caught too.
+     */
+    maxDepth: number;
+    /**
+     * Decorator-style resolver registration.
+     *
+     * Resolvers may be synchronous OR async (return a Promise) — `execute()`
+     * awaits every resolver, so an `async` resolver's value is resolved before
+     * the field is serialized. Return a value directly, or `await` your data
+     * (e.g. an async DB driver) and the executor will await it for you.
+     *
+     *     GraphQL.resolve("Query", "products", async (root, args) =>
+     *       (await db.fetch("SELECT * FROM products")).records);
+     *
+     *     GraphQL.resolve("Mutation", "createProduct", async (root, args) => {
+     *       const p = new Product(args.input);
+     *       await p.save();
+     *       return p.toDict();
+     *     });
+     *
+     *     GraphQL.resolve("Product", "reviews", async (product, args) =>
+     *       (await db.fetch("SELECT * FROM reviews WHERE product_id = ?", [product.id])).records);
+     *
+     * Resolvers registered before any GraphQL instance exists accumulate
+     * in the class-level registry. `new GraphQL()` drains them into its
+     * schema. Resolvers registered after `setDefault(gql)` wire into the
+     * live schema immediately.
+     */
+    static resolve(typeName: string, fieldName: string, resolver: ResolverFn): void;
+    /**
+     * Designate `instance` as the default singleton. Post-startup
+     * `GraphQL.resolve()` calls wire into this instance's live schema.
+     */
+    static setDefault(instance: GraphQL): void;
+    /** Test-only — clear the class-level registry. */
+    static _clearClassResolvers(): void;
+    constructor();
+    /** Wire a single resolver into the live schema. */
+    private attachResolver;
+    /**
+     * Get the field resolver registered for an object type, if any.
+     * Used by the executor during nested field resolution.
+     */
+    getFieldResolver(typeName: string, fieldName: string): ResolverFn | undefined;
+    /**
+     * Return schema metadata for debugging.
+     */
+    introspect(): Record<string, unknown>;
+    /**
+     * Register a named type with its fields.
+     */
+    addType(name: string, fields: Record<string, GraphQLField>): GraphQL;
+    /**
+     * Register a query resolver.
+     */
+    addQuery(name: string, args: Record<string, string>, returnType: string, resolver: ResolverFn): GraphQL;
+    /**
+     * Register a mutation resolver.
+     */
+    addMutation(name: string, args: Record<string, string>, returnType: string, resolver: ResolverFn): GraphQL;
+    /**
+     * Execute a GraphQL query string.
+     */
+    execute(query: string, variables?: Record<string, unknown>, context?: Record<string, unknown>): Promise<GraphQLResult>;
+    /**
+     * Resolve a list of selections and merge results into the `target` dict.
+     * Fragment spreads and inline fragments are merged (not nested).
+     *
+     * `depth` is incremented on every recursive entry (field sub-selections,
+     * fragment spreads, inline fragments) and checked against `maxDepth` so an
+     * over-deep query or a circular fragment fails with a structured error
+     * instead of recursing until the interpreter stack overflows. Top-level
+     * starts at depth 1; `maxDepth <= 0` disables the guard.
+     */
+    private resolveSelectionsInto;
+    /**
+     * Generate SDL schema string.
+     */
+    schemaSdl(): string;
+    /**
+     * Auto-generate type, queries, and CRUD mutations from an ORM model class.
+     *
+     * The model class must have static `tableName` (string) and `fields`
+     * (Record<string, { type: string; primaryKey?: boolean }>).
+     *
+     * Creates:
+     *   - A GraphQL type from the model's fields
+     *   - Queries: {modelName}(id: ID!): Type, {modelNames}(limit: Int, offset: Int): [Type]
+     *   - Mutations: create{ModelName}, update{ModelName}, delete{ModelName}
+     *
+     * @param modelClass - The model class with static tableName and fields
+     * @param adapter - Optional database adapter; if omitted, resolvers will
+     *                  import getAdapter from @tina4/orm at call time
+     */
+    fromOrm(modelClass: {
+        tableName: string;
+        fields: Record<string, {
+            type: string;
+            primaryKey?: boolean;
+        }>;
+        name?: string;
+    }, adapter?: {
+        query: <T = Record<string, unknown>>(sql: string, params?: unknown[]) => T[];
+        execute: (sql: string, params?: unknown[]) => unknown;
+    }): GraphQL;
+    private formatArgs;
+    private resolveField;
+    private resolveArgs;
+    /**
+     * Check directives: @skip, @include, @auth, @role, @guest.
+     * Returns true if the field should be included, false to skip.
+     */
+    private checkDirectives;
+    /**
+     * Validate resolved args against declared types.
+     */
+    private validateArgs;
+    private coerceValue;
+}
+/**
+ * Lightweight GraphQL type wrapper matching Ruby's GraphQLType.
+ */
+export declare class GraphQLType {
+    static readonly SCALARS: string[];
+    name: string;
+    kind: string;
+    ofType: GraphQLType | null;
+    constructor(name: string, kind?: string, ofType?: GraphQLType | null);
+    /**
+     * Parse a GraphQL type string like "String", "String!", "[Int!]!".
+     */
+    static parse(typeStr: string): GraphQLType;
+}
+export {};

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

@@ -0,0 +1,22 @@
+import type { RouteDefinition } from "./types.js";
+/**
+ * Resolve the health route path. Priority:
+ *   1. `TINA4_HEALTH_PATH` env var
+ *   2. Default `/__health` (matches Python parity — under-prefix avoids
+ *      colliding with app routes named /health)
+ */
+export declare function healthPath(): string;
+/**
+ * Create the primary health route definition.
+ *
+ * Tests use this directly. Server bootstrap goes through createHealthRoutes()
+ * to also register the legacy `/health` alias when TINA4_HEALTH_PATH points
+ * elsewhere — matching Python behaviour so existing probes don't break.
+ */
+export declare function createHealthRoute(version?: string): RouteDefinition;
+/**
+ * Create one or two health routes — the env-defined path always, plus a
+ * legacy `/health` alias when the env path differs. Mirrors
+ * tina4-python's two-line registration in `core/server.py`.
+ */
+export declare function createHealthRoutes(version?: string): RouteDefinition[];

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

@@ -0,0 +1,75 @@
+/**
+ * Programmatic HTML builder — avoids string concatenation.
+ *
+ * Usage:
+ *   const el = new HtmlElement("div", { class: "card" }, ["Hello"]);
+ *   el.toString();  // '<div class="card">Hello</div>'
+ *
+ *   // Builder pattern
+ *   const el = htmlElement("div")(htmlElement("p")("Text"));
+ *
+ *   // Helper functions
+ *   const h: Record<string, any> = {};
+ *   addHtmlHelpers(h);
+ *   const html = h._div({ class: "card" }, h._p("Hello"));
+ */
+/**
+ * Raw — marker for trusted, pre-sanitised HTML that must render UNESCAPED.
+ *
+ * String/scalar children of an HtmlElement are HTML-escaped by default to
+ * prevent stored/reflected XSS. Wrap a value in Raw to opt out of escaping
+ * when (and only when) you have already sanitised it yourself.
+ *
+ *   new HtmlElement("div", {}, ["<b>x</b>"]).toString()           // &lt;b&gt;x&lt;/b&gt;  (escaped)
+ *   new HtmlElement("div", {}, [new Raw("<b>x</b>")]).toString()  // <b>x</b>              (raw)
+ *
+ * Alias: SafeString.
+ */
+export declare class Raw {
+    readonly value: string;
+    constructor(value: string);
+    toString(): string;
+}
+export declare const SafeString: typeof Raw;
+type Attrs = Record<string, string | number | boolean | null | undefined>;
+type Child = string | number | HtmlElement | Raw;
+/**
+ * HtmlElement — a single HTML tag with attributes and children.
+ */
+export declare class HtmlElement {
+    readonly tag: string;
+    readonly attrs: Attrs;
+    readonly children: Child[];
+    constructor(tag: string, attrs?: Attrs, children?: Child[]);
+    /**
+     * Render to HTML string.
+     */
+    toString(): string;
+}
+/**
+ * Create a callable HTML element builder.
+ * Returns a function that, when called with children/attrs, produces a new HtmlElement.
+ *
+ * Usage:
+ *   const div = htmlElement("div");
+ *   const el = div({ class: "card" }, "Hello");
+ *   console.log(el.toString());  // '<div class="card">Hello</div>'
+ */
+export declare function htmlElement(tag: string, attrs?: Attrs, children?: Child[]): {
+    (...args: (Child | Attrs | Child[])[]): /*elided*/ any;
+    tag: string;
+    attrs: Attrs;
+    children: Child[];
+    toString(): string;
+    _isHtmlElement: boolean;
+};
+/**
+ * Injects helper functions (_div, _p, _a, _span, etc.) into the target object.
+ *
+ * Usage:
+ *   const h: Record<string, any> = {};
+ *   addHtmlHelpers(h);
+ *   const html = h._div({ class: "card" }, h._p("Hello"));
+ */
+export declare function addHtmlHelpers(target: Record<string, unknown>): void;
+export {};

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

@@ -0,0 +1,37 @@
+export declare class I18n {
+    private _localeDir;
+    private _defaultLocale;
+    private _currentLocale;
+    private _translations;
+    /**
+     * @param locale  Default locale code (e.g. "en"). Falls back to
+     *                TINA4_LOCALE, then "en".
+     * @param path    Directory holding the JSON/YAML locale files. Falls back to
+     *                TINA4_LOCALE_DIR, then "src/locales".
+     *
+     * Arg order is (locale, path) to match the Python master `I18n(locale, path)`
+     * (BUG-7, BREAKING in 3.13.x — was previously (localeDir, defaultLocale)).
+     */
+    constructor(locale?: string, path?: string);
+    setLocale(locale: string): void;
+    getLocale(): string;
+    /**
+     * Translate a key. Supports {placeholder} interpolation.
+     * Falls back to default locale, then returns the key itself.
+     */
+    t(key: string, params?: Record<string, string>, locale?: string): string;
+    /** Alias for t() */
+    translate(key: string, params?: Record<string, string>, locale?: string): string;
+    /** Load and return translations for a locale. */
+    loadTranslations(locale: string): Record<string, string>;
+    /** Add a single translation key/value to a locale (in-memory only). */
+    addTranslation(locale: string, key: string, value: string): void;
+    /** List available locale codes based on JSON files in the locale directory. */
+    availableLocales(): string[];
+    /** Load a locale file if not already loaded. */
+    private _loadLocale;
+    /** Flatten nested objects: {"a": {"b": "c"}} → {"a.b": "c"} */
+    /** Zero-dep YAML parser for simple key: value locale files. */
+    private static _parseSimpleYaml;
+    private static _flatten;
+}

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

@@ -0,0 +1,93 @@
+export type { Tina4Request, Tina4Response, RouteHandler, RouteDefinition, RouteMeta, Tina4Config, Middleware, MiddlewareSpec, UploadedFile, CookieOptions, WebSocketRouteHandler, WebSocketRouteDefinition, } from "./types.js";
+export { startServer, resolvePortAndHost, handle, start, stop, httpReason, resolveTemplate, resetTemplateCache, templateAutoRoutingEnabled, isBannerSuppressed } from "./server.js";
+export { background, stopAllBackgroundTasks, backgroundTaskCount } from "./background.js";
+export { Router, RouteGroup, RouteRef, WsRouteRef, defaultRouter, runRouteMiddlewares, resolveStringMiddleware, isTrailingSlashRedirectEnabled } from "./router.js";
+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 type { CorsConfig } from "./middleware.js";
+export { createRequest, makeCaseInsensitiveHeaders } from "./request.js";
+export { createResponse, errorResponse, setDefaultTemplatesDir, getFrond, setFrond, getFrameworkFrond } 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 { createHealthRoute, createHealthRoutes, healthPath } from "./health.js";
+export { rateLimiter } from "./rateLimiter.js";
+export type { RateLimiterConfig } from "./rateLimiter.js";
+export { HTTP_OK, HTTP_CREATED, HTTP_ACCEPTED, HTTP_NO_CONTENT, HTTP_MOVED, HTTP_REDIRECT, HTTP_NOT_MODIFIED, HTTP_BAD_REQUEST, HTTP_UNAUTHORIZED, HTTP_FORBIDDEN, HTTP_NOT_FOUND, HTTP_METHOD_NOT_ALLOWED, HTTP_CONFLICT, HTTP_GONE, HTTP_UNPROCESSABLE, HTTP_TOO_MANY, HTTP_SERVER_ERROR, HTTP_BAD_GATEWAY, HTTP_UNAVAILABLE, APPLICATION_JSON, APPLICATION_XML, APPLICATION_FORM, APPLICATION_OCTET, TEXT_HTML, TEXT_PLAIN, TEXT_CSV, TEXT_XML, } from "./constants.js";
+export { getToken, validToken, getPayload, hashPassword, checkPassword, authMiddleware, refreshToken, authenticateRequest, validateApiKey, ensureDevSecret, Auth, } from "./auth.js";
+export { Session, FileSessionHandler, RedisSessionHandler, buildSessionCookie, isSecureScheme, sessionCookieName } from "./session.js";
+export type { SessionConfig, SessionHandler } from "./session.js";
+export { I18n } from "./i18n.js";
+export { FakeData } from "./fakeData.js";
+export { ScssCompiler } from "./scss.js";
+export type { ScssConfig } from "./scss.js";
+export { Queue } from "./queue.js";
+export type { QueueConfig, QueueJob, ProcessOptions } from "./queue.js";
+export { createJob } from "./job.js";
+export type { JobData, JobQueueBridge } from "./job.js";
+export { Mqtt, MqttError, MqttTimeoutError } from "./mqtt.js";
+export type { MqttOptions, ParsedMqttUrl } from "./mqtt.js";
+export { MqttMessage } from "./mqttMessage.js";
+export type { MqttAcknowledger } from "./mqttMessage.js";
+export { GraphQL, ParseError, graphqlEndpoint, graphqlAutoSchemaEnabled, graphqlMaxDepth } from "./graphql.js";
+export type { GraphQLField, ResolverFn, GraphQLResult } from "./graphql.js";
+export { WebSocketServer, devReloadWs, computeAcceptKey, parseUpgradeHeaders, buildFrame, parseFrame, originAllowed, wsToken, wsAuthorized, offeredBearerSubprotocol, serveWebSocketRoute, wsRouteManager, OP_TEXT, OP_BINARY, OP_CLOSE, OP_PING, OP_PONG, CLOSE_NORMAL, CLOSE_GOING_AWAY, CLOSE_PROTOCOL_ERROR, CLOSE_POLICY_VIOLATION, } from "./websocket.js";
+export type { WebSocketClient } from "./websocket.js";
+export { ServiceRunner, Tina4Service, matchCronField, matchesCron } from "./service.js";
+export type { ServiceOptions, ServiceContext, ServiceHandler, ServiceInfo } from "./service.js";
+export { responseCache, clearCache, cacheStats, cacheGet, cacheSet, cacheDelete, cacheClear, cacheBackendStats, createBackend, _resetBackend } from "./cache.js";
+export type { ResponseCacheConfig, CacheBackend } from "./cache.js";
+export { Api } from "./api.js";
+export type { ApiResult, ApiOptions, ApiTransport, DownloadResult, UploadOptions } from "./api.js";
+export { Context, defaultContext, existingContext, fts5Supported, _sharedContexts } from "./context/index.js";
+export type { SearchHit } from "./context/index.js";
+export { Events } from "./events.js";
+export { DevAdmin, MessageLog, RequestInspector, ErrorTracker, DevMailboxStore, DevQueue, WsTracker, supervisorBaseUrl, devAdminLanguage } from "./devAdmin.js";
+export { feedbackEnabled, feedbackWhitelist, feedbackIdentifyUser, feedbackIsWhitelisted, feedbackRateLimitOk, injectFeedbackWidget, handleFeedbackTurn, handleFeedbackWidgetJs, registerFeedbackRoutes, } from "./feedback.js";
+export { Messenger, MessengerConnectionError, createMessenger } from "./messenger.js";
+export type { SendResult, EmailMessage } from "./messenger.js";
+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 { AI_TOOLS, isInstalled, showMenu, installSelected, installAll, generateContext } from "./ai.js";
+export type { AiTool } from "./ai.js";
+export type { ImapMessage, ImapFullMessage } from "./messenger.js";
+export { LiteBackend } from "./queueBackends/liteBackend.js";
+export { RabbitMQBackend, parseAmqpUrl } from "./queueBackends/rabbitmqBackend.js";
+export type { RabbitMQConfig } from "./queueBackends/rabbitmqBackend.js";
+export { KafkaBackend, kafkaSecurityConfig } from "./queueBackends/kafkaBackend.js";
+export type { KafkaConfig, KafkaSecurityConfig, KafkaClientConfig, } from "./queueBackends/kafkaBackend.js";
+export { MongoBackend } from "./queueBackends/mongoBackend.js";
+export type { MongoConfig as MongoQueueConfig } from "./queueBackends/mongoBackend.js";
+export { DatabaseSessionHandler } from "./sessionHandlers/databaseHandler.js";
+export type { DatabaseSessionConfig } from "./sessionHandlers/databaseHandler.js";
+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 { RedisNpmSessionHandler } from "./sessionHandlers/redisHandler.js";
+export type { RedisNpmSessionConfig } from "./sessionHandlers/redisHandler.js";
+export { tests, assertEqual, assertRaises, assertTrue, assertFalse, 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";
+export { Container, container } from "./container.js";
+export { Validator } from "./validator.js";
+export type { ValidationError } from "./validator.js";
+export type { WebSocketConnection } from "./websocketConnection.js";
+export { RedisBackplane, NATSBackplane, createBackplane, WsBackplaneManager, buildEnvelope, WS_BACKPLANE_CHANNEL, } from "./websocketBackplane.js";
+export type { WebSocketBackplane, WsEnvelope, WsEnvelopeKind, WsBackplaneLogger, } from "./websocketBackplane.js";
+export { McpServer, mcpTool, mcpResource, registerDevTools, getDefaultDevServer, encodeResponse, encodeError, encodeNotification, decodeRequest, schemaFromParams, isLocalhost, isLoopback, mcpEnabled, isRequestAllowed, mcpPort, PARSE_ERROR, INVALID_REQUEST, METHOD_NOT_FOUND, INVALID_PARAMS, INTERNAL_ERROR, } from "./mcp.js";
+export type { JsonRpcMessage, McpToolDefinition, McpResourceDefinition, JsonSchema, McpToolParam } from "./mcp.js";
+export { Plan } from "./plan.js";
+export type { PlanStep, ParsedPlan, PlanSummary, ExecutionSummary, CurrentPlan } from "./plan.js";
+export { ProjectIndex } from "./projectIndex.js";
+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";