tina4-nodejs 3.13.132 → 3.13.134

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

@@ -97,6 +97,7 @@ export declare class Frond {
     private _allowedVars;
     private fragmentCache;
     private _autoEscape;
+    private readonly blockHandlers;
     /**
      * Token pre-compilation cache for file templates.
      *
@@ -188,6 +189,10 @@ export declare class Frond {
      */
     private substituteBlocks;
     private renderWithBlocks;
+    private dispatchBlock;
+    private renderTextToken;
+    private renderVarToken;
+    private renderBlockToken;
     private renderTokens;
     /**
      * May this filter RUN under the current sandbox?
@@ -206,6 +211,7 @@ export declare class Frond {
      * instead of the four names that happened to be checked individually.
      */
     private tagPermitted;
+    private applyFilterValue;
     /**
      * Consume a denied tag WITHOUT running it, returning the index past its body.
      *
@@ -228,8 +234,22 @@ export declare class Frond {
     private applyFilters;
     private evalVar;
     private evalVarRaw;
+    /**
+     * Apply the no-argument filters that are common enough to avoid generic
+     * dispatch. Keeping this table separate from evalVarInner makes the
+     * expression pipeline easier to audit without changing filter order.
+     */
+    private applyFastFilter;
+    private applyRenderedFilter;
+    private variablePermitted;
+    private resolveConcatenation;
+    private applyRenderedFilters;
     private evalVarInner;
+    private pushIfBranch;
+    private collectIfBranches;
     private handleIf;
+    private collectForTokens;
+    private forItems;
     private handleFor;
     private handleSet;
     private handleInclude;
@@ -257,6 +277,8 @@ export declare class Frond {
      */
     private handleImportAs;
     private handleFromImport;
+    private collectMacroDefinitions;
+    private createMacro;
     /**
      * Collect the body tokens of a {% <openTag> %}...{% end<openTag> %} block,
      * starting from the token after the opening tag (start + 1). Nested same-tag
@@ -279,6 +301,9 @@ export declare class Frond {
      * Python master's _handle_live and PHP/Ruby handleLive.
      */
     private handleLive;
+    private parseLiveOptions;
+    private collectLiveBody;
+    private liveAttributes;
     /**
      * Re-render a registered {% live %} fragment by name with fresh data.
      * Returns the rendered HTML, or null if no fragment is registered under that

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

@@ -19,6 +19,9 @@ export declare class FakeData extends CoreFakeData {
      * Matches the Python API's datetime() method.
      */
     datetime(startYear?: number, endYear?: number): Date;
+    private heuristicValue;
+    private stringValue;
+    private typedValue;
     /**
      * Generate a fake value appropriate for an ORM field definition.
      * Respects min/max, minLength/maxLength, and type constraints.

package/types/orm/src/seeder.d.ts

@@ -1,92 +1,7 @@
-import { FakeData } from "./fakeData.js";
 import type { DatabaseAdapter, FieldDefinition } from "./types.js";
-/**
- * Result of a seed run — `{ seeded, failed, errors }`.
- *
- * `errors` is a list of `{ row, message }` describing every skipped row
- * (`row` is the 0-based index). Mirrors the Python `SeedSummary`; Node tests
- * compare `.seeded` / `.failed` rather than the bare integer.
- */
-export interface SeedSummary {
-    seeded: number;
-    failed: number;
-    errors: Array<{
-        row: number;
-        message: string;
-    }>;
-}
-/** Options shared by seedTable / seedOrm / seedModels. */
-export interface SeedOptions {
-    /** Static values applied to every row (overrides generated values). */
-    overrides?: Record<string, unknown>;
-    /** Delete every existing row in the target before seeding (P2). */
-    clear?: boolean;
-    /**
-     * PRNG seed for reproducible FakeData output (P3). Honoured by seedOrm and
-     * seedModels, which build and seed their own FakeData internally.
-     *
-     * NOT honoured by seedTable (SEED-TABLE-SEED-INERT, SEED-DEC-01, ratified
-     * 2026-08-11 — same principle as the no-op ForeignKeyField on_delete):
-     * seedTable has no generators of its own to seed — fieldMap callables are
-     * opaque — so this used to be a silent no-op there. Passing it to seedTable
-     * now THROWS instead. Build your own `new FakeData(seed)` and close over it
-     * in fieldMap: `const fake = new FakeData(42); seedTable(db, table, count,
-     * { name: () => fake.name() })`.
-     */
-    seed?: number;
-    /** Re-raise on the first failed row instead of skipping it (P1). */
-    strict?: boolean;
-}
-/**
- * Introspect `table`'s columns and build a column->generator field map for
- * {@link seedTable}, skipping the auto-increment / `id` primary key (the engine
- * assigns it). Mirrors the Python master's `auto_field_map`
- * (tina4_python/seeder/__init__.py): the shared "seed a table I did not
- * hand-write generators for" helper that both the dev-admin seed endpoint and
- * the MCP `seed_table` dev tool use — `seedTable` itself stays explicit
- * (no map = no rows), and this is how a caller opts into automatic generation.
- *
- * Reuses `FakeData.forField()` (column-name + type heuristics) so the generated
- * data matches every other Tina4 seeding path. Returns an empty map when the
- * table has no seedable columns, so `seedTable` then seeds nothing rather than
- * crashing.
- *
- * @param db - A DatabaseAdapter instance (pass `getAdapter()`, NOT the Database
- *             wrapper — the wrapper has no `columns()`).
- * @param table - The table to introspect.
- * @param fake - Optional shared FakeData (pass one seeded via `new FakeData(n)`
- *               for reproducible output).
- * @returns `{ column -> () => value }`, ready to hand to `seedTable`.
- */
-export declare function autoFieldMap(db: DatabaseAdapter, table: string, fake?: FakeData): Promise<Record<string, () => unknown>>;
-/**
- * Seed a database table with fake data using raw SQL inserts.
- *
- * Visible-but-resilient (P1): each row is wrapped. On a row failure the cause
- * is logged (with the row index) and the row is skipped — unless `strict: true`,
- * in which case the first failure RE-RAISES. At the end a one-line summary is
- * logged ("seeded N, M failed").
- *
- * @param db - A DatabaseAdapter instance
- * @param tableName - The table to insert into
- * @param count - Number of rows to insert (default 10)
- * @param fieldMap - Dict of column_name -> callable that generates a value
- *                   (or a static value). If not provided, no rows are inserted.
- * @param overrides - (legacy positional) Static values applied to every row.
- *                   Prefer `opts.overrides`.
- * @param opts - Seed options: `{ overrides, clear, strict }`. `opts.seed` is
- *   NOT honoured here (see {@link SeedOptions.seed}) and throws if supplied.
- * @returns A SeedSummary `{ seeded, failed, errors }`.
- * @throws {Error} If `opts.seed` is defined (SEED-TABLE-SEED-INERT removal).
- *
- * @example
- *   const fake = new FakeData();
- *   await seedTable(db, "users", 50, {
- *     name: () => fake.name(),
- *     email: () => fake.email(),
- *   }, undefined, { clear: true });
- */
-export declare function seedTable(db: DatabaseAdapter, tableName: string, count?: number, fieldMap?: Record<string, (() => unknown) | unknown>, overrides?: Record<string, unknown>, opts?: SeedOptions): Promise<SeedSummary>;
+import type { SeedOptions, SeedSummary } from "./seederTypes.js";
+export { autoFieldMap, seedTable } from "./seederTable.js";
+export type { SeedOptions, SeedSummary } from "./seederTypes.js";
 /** A model-like shape the seeder can drive (real BaseModel subclass or mock). */
 interface SeedableModel {
     tableName: string;
@@ -128,4 +43,3 @@ export declare function seedOrm(ormClass: SeedableModel, count?: number, overrid
 export declare function seedModels(ormClasses: SeedableModel[], count?: number, opts?: SeedOptions & {
     overrides?: Record<string, unknown> | Map<SeedableModel, Record<string, unknown>>;
 }): Promise<Record<string, SeedSummary>>;
-export {};

package/types/orm/src/seederTable.d.ts

@@ -0,0 +1,9 @@
+import { FakeData } from "./fakeData.js";
+import type { DatabaseAdapter } from "./types.js";
+import type { SeedOptions, SeedSummary } from "./seederTypes.js";
+/** Delete every row, logging but not hiding a clear failure. */
+export declare function clearTable(db: DatabaseAdapter, tableName: string): Promise<void>;
+/** Build generators from live table metadata for the explicit seedTable path. */
+export declare function autoFieldMap(db: DatabaseAdapter, table: string, fake?: FakeData): Promise<Record<string, () => unknown>>;
+/** Seed a table through the adapter insert path, counting or re-raising row failures. */
+export declare function seedTable(db: DatabaseAdapter, tableName: string, count?: number, fieldMap?: Record<string, (() => unknown) | unknown>, overrides?: Record<string, unknown>, opts?: SeedOptions): Promise<SeedSummary>;

package/types/orm/src/seederTypes.d.ts

@@ -0,0 +1,16 @@
+/** Result of a seed run. */
+export interface SeedSummary {
+    seeded: number;
+    failed: number;
+    errors: Array<{
+        row: number;
+        message: string;
+    }>;
+}
+/** Options shared by the table and ORM seed paths. */
+export interface SeedOptions {
+    overrides?: Record<string, unknown>;
+    clear?: boolean;
+    seed?: number;
+    strict?: boolean;
+}