typhex 0.1.0-alpha.0

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to Typhex will be documented in this file.
+
+Typhex follows semantic versioning for the documented public API. During the
+0.x series, APIs may still change while the package is being hardened.
+
+## Unreleased
+
+## 0.1.0-alpha.0 - 2026-06-15
+
+- Initial public alpha preview.
+- Added release hardening metadata and package verification scripts.
+- Added CI quality gates for linting, formatting, API compatibility, coverage,
+  and package dry-runs.
+- Added an explicit MIT license file.
+- Added a production dependency audit gate for release checks.
+- Added deterministic parser/compiler fuzz coverage across SQLite and PostgreSQL
+  SQL compilation.
+- Upgraded Vitest and coverage tooling to remove critical dev audit findings.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ioannis Kalyvas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,417 @@
+# Typhex
+
+[![CI](https://github.com/kalyvasio/typhex/actions/workflows/ci.yml/badge.svg)](https://github.com/kalyvasio/typhex/actions/workflows/ci.yml)
+[![Docs](https://github.com/kalyvasio/typhex/actions/workflows/docs.yml/badge.svg)](https://github.com/kalyvasio/typhex/actions/workflows/docs.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+A TypeScript/JavaScript ORM that lets you write SQL queries with arrow-function predicates:
+
+```ts
+const adults = await User.query()
+  .where((u) => u.age > 18)
+  .toArray();
+```
+
+Typhex compiles those predicates to safe, parameterized SQL through either a TypeScript transformer or a runtime parser.
+
+## Why Typhex?
+
+- **Type-safe queries**: TypeScript understands your entity shape.
+- **No SQL injection**: Generated SQL is parameterized.
+- **Familiar syntax**: Write predicates like normal JavaScript/TypeScript expressions.
+- **Compile-time mode**: The transformer auto-captures closure variables and avoids runtime parsing.
+- **Runtime fallback**: Plain JavaScript and direct `tsx` scripts work with explicit closure variables.
+- **ORM features**: Relations, aggregations, transactions, bulk inserts, upserts, and graph inserts.
+
+## Installation
+
+For SQLite:
+
+```bash
+npm install typhex better-sqlite3
+```
+
+For PostgreSQL:
+
+```bash
+npm install typhex pg
+```
+
+For TypeScript projects, install the transformer tooling too:
+
+```bash
+npm install --save-dev ts-patch
+```
+
+`better-sqlite3` includes a native addon. If installation fails, install local build tools first: `xcode-select --install` on macOS, or `build-essential` or equivalent on Linux.
+
+## Quick Start
+
+### Define a Schema
+
+```ts
+import { Db, Entity, createSqliteDriver } from "typhex";
+
+const User = Entity("users", {
+  id: "integer primary key autoincrement",
+  name: "text not null",
+  age: "integer not null",
+  country: "text not null",
+});
+```
+
+### Connect and Migrate
+
+```ts
+const db = new Db(createSqliteDriver({ path: "./app.db" }));
+
+await db.migrate();
+```
+
+### Insert Rows
+
+```ts
+await User.query().insert({ name: "Alice", age: 30, country: "US" });
+await User.query().insert({ name: "Bob", age: 25, country: "UK" });
+```
+
+### Query Rows
+
+```ts
+const adults = await User.query()
+  .where((u) => u.age > 18)
+  .orderBy((u) => u.name, "asc")
+  .toArray();
+
+const firstAdult = await User.query()
+  .where((u) => u.age > 18)
+  .first();
+
+const alice = await User.query().findById(1);
+const usCount = await User.query()
+  .where((u) => u.country === "US")
+  .count();
+```
+
+### Update, Patch, and Delete
+
+```ts
+await User.query()
+  .where((u) => u.name === "Bob")
+  .update({ age: 26 });
+
+const updated = await User.query()
+  .where((u) => u.name === "Alice")
+  .patch({ country: "CA" });
+
+await User.query()
+  .where((u) => u.country === "UK")
+  .delete();
+```
+
+`update()` returns the number of rows changed. `patch()` performs the update and returns the updated row.
+
+## Runtime vs Transformer Mode
+
+Typhex has two ways to turn arrow functions into query IR.
+
+### Runtime Mode
+
+Runtime mode works in JavaScript, direct `tsx` scripts, and projects without a TypeScript compiler plugin. Closure variables must be passed explicitly:
+
+```ts
+const country = "US";
+
+const users = await User.query()
+  .where((u) => u.country === country, { country })
+  .toArray();
+```
+
+### Transformer Mode
+
+Transformer mode is recommended for TypeScript projects. It compiles predicates at build time and auto-captures closure variables.
+
+```json
+{
+  "compilerOptions": {
+    "plugins": [{ "transform": "typhex/transformer" }]
+  }
+}
+```
+
+```bash
+npx ts-patch install
+```
+
+After setup, no second argument is needed:
+
+```ts
+const country = "US";
+const minAge = 25;
+
+const users = await User.query()
+  .where((u) => u.country === country && u.age >= minAge)
+  .toArray();
+```
+
+See the [TypeScript transformer guide](docs/guide/typescript-transformer.md) for setup details and dev-time notes.
+
+## Querying
+
+### Filtering, Ordering, and Paging
+
+```ts
+const users = await User.query()
+  .where((u) => u.age >= 18 && u.country === "US")
+  .orderBy((u) => u.age, "desc")
+  .limit(10)
+  .offset(20)
+  .toArray();
+```
+
+### Selecting Columns
+
+```ts
+const names = await User.query().select(["name", "country"]).toArray();
+
+const projected = await User.query()
+  .select((u) => ({ userId: u.id, displayName: u.name }))
+  .toArray();
+```
+
+### String Predicates and IN
+
+```ts
+const matching = await User.query()
+  .where((u) => u.name.startsWith("A") || u.name.includes("son"))
+  .toArray();
+
+const ids = [1, 2, 3];
+const selected = await User.query()
+  .where((u) => u.id in ids, { ids })
+  .toArray();
+```
+
+With the transformer enabled, captured arrays do not need the second argument.
+
+### Subqueries
+
+`IN` and `NOT IN` subqueries work in runtime and transformer mode. Runtime mode passes the inner query through the params object:
+
+```ts
+const activePostIds = Post.query()
+  .where((p) => p.active === 1)
+  .select((p) => p.id);
+
+const authors = await Author.query()
+  .where((a, posts) => a.postId in posts, { posts: activePostIds })
+  .toArray();
+```
+
+Transformer mode can inline the inner query:
+
+```ts
+const authors = await Author.query()
+  .where(
+    (a) =>
+      a.postId in
+      Post.query()
+        .where((p) => p.active === 1)
+        .select((p) => p.id),
+  )
+  .toArray();
+```
+
+Scalar subqueries in `.select()`, `.where()` comparisons, and `.orderBy()` are transformer-only. See the [Subqueries guide](docs/guide/subqueries.md) for the supported shapes.
+
+### CTEs and Unions
+
+Use common table expressions when an inner query should be named and reused by an outer query:
+
+```ts
+const adults = User.query().where((u) => u.age >= 18);
+
+const workingAge = await User.query()
+  .withCte("adults", adults)
+  .from("adults")
+  .where((u) => u.age < 65)
+  .toArray();
+```
+
+Typhex also supports `unionAll()`, recursive CTEs, entity-table joins for recursive branches, and CTE-correlated `update()` / `delete()`. See the [CTEs and Unions guide](docs/guide/cte-and-unions.md).
+
+## Supported Predicate Syntax
+
+Runtime mode supports a practical safe subset:
+
+- Comparisons: `===`, `!==`, `==`, `!=`, `>`, `>=`, `<`, `<=`
+- Logical operators: `&&`, `||`, `!`
+- Member access, literals, array literals, and the `in` operator
+- String methods: `.startsWith()`, `.endsWith()`, `.includes()`
+- Aggregates in `.select()` and `.having()`: `count()`, `sum()`, `avg()`, `min()`, `max()`, `distinct(...)`
+- Relation predicates such as `department.employees.some((e) => e.name === "Alice")`
+- Universal relation predicates such as `department.employees.every((e) => e.active === true)`
+- Relation query chains in `.select()`
+
+Computed expressions (ternaries, arithmetic, bitwise operators, null checks) are also supported — see the [Expressions guide](docs/guide/expressions.md).
+
+Runtime mode does not support unsigned right shift (`>>>`), optional chaining, nullish coalescing, arbitrary function calls, loops, assignments, `await`, `new`, or `instanceof`.
+
+## Relations
+
+Declare relations as the third argument to `Entity()`:
+
+```ts
+import { Entity, rel } from "typhex";
+
+const Post = Entity(
+  "posts",
+  {
+    id: "integer primary key autoincrement",
+    title: "text not null",
+    authorId: "integer not null",
+  },
+  {
+    author: rel.manyToOne(() => User, { foreignKey: "authorId" }),
+  },
+);
+```
+
+Then use relation properties in `select()` and `where()`:
+
+```ts
+const posts = await Post.query()
+  .where((p) => p.author.country === "US")
+  .select((p) => ({ id: p.id, title: p.title, author: p.author }))
+  .toArray();
+```
+
+Typhex supports `manyToOne`, `oneToMany`, `oneToOne`, and `manyToMany` relations. Relation selects avoid N+1 queries by batching related rows.
+
+See [Entities & Relations](docs/guide/entities-relations.md), [Querying Relations](docs/guide/querying-relations.md), and [Filtering by Relations](docs/guide/filtering-by-relations.md).
+
+## Aggregations
+
+```ts
+import { count, sum } from "typhex";
+
+const statsByCountry = await User.query()
+  .select((u) => ({ country: u.country, users: count(u.id), totalAge: sum(u.age) }))
+  .groupBy((u) => u.country)
+  .having((u) => count(u.id) > 1)
+  .toArray();
+```
+
+Typhex supports `GROUP BY`, `HAVING`, `distinct()`, and database-specific aggregates such as SQLite `groupConcat()` and PostgreSQL `stringAgg()`, `arrayAgg()`, and `jsonAgg()`.
+
+See the [Aggregations guide](docs/guide/aggregations.md).
+
+## Bulk and Graph Operations
+
+### Bulk Inserts
+
+```ts
+await Product.query().insertMany([
+  { sku: "W-001", name: "Widget", price: 999 },
+  { sku: "G-001", name: "Gadget", price: 1499 },
+]);
+```
+
+### Upserts
+
+```ts
+await Product.query()
+  .insert({ sku: "W-001", name: "Widget v2", price: 1099 })
+  .onConflict(["sku"])
+  .doUpdate(["name", "price"]);
+```
+
+### Graph Inserts
+
+```ts
+const post = await Post.query().insertGraph({
+  title: "Hello",
+  author: { name: "Alice" },
+  tags: [{ name: "typescript" }, { name: "orm" }],
+});
+```
+
+See the [Bulk Operations guide](docs/guide/bulk-operations.md).
+
+## Transactions
+
+Use `db.transaction()` for callback-style transactions with implicit propagation:
+
+```ts
+await db.transaction(async () => {
+  const user = await User.query().insert({ name: "Alice", age: 30, country: "US" });
+  await Post.query().insert({ title: "Hello", authorId: user.id });
+});
+```
+
+Use `db.beginTrx()` when you need to pass a transaction handle through service layers:
+
+```ts
+const trx = await db.beginTrx();
+
+try {
+  await User.query(trx).insert({ name: "Bob", age: 26, country: "UK" });
+  await trx.commit();
+} catch {
+  await trx.rollback();
+}
+```
+
+Nested transactions use savepoints. Transaction options include isolation level, PostgreSQL read-only/deferrable flags, and SQLite transaction mode.
+
+See the [Transactions guide](docs/guide/transactions.md).
+
+## Debugging
+
+Set `TYPHEX_DEBUG=1` to log SQL and parameters:
+
+```bash
+TYPHEX_DEBUG=1 npx tsx your-script.ts
+```
+
+`true` and `yes` are also accepted.
+
+## Architecture
+
+Typhex uses a query IR (Intermediate Representation) that bridges arrow-function predicates and SQL:
+
+1. Arrow functions are converted to IR through the runtime parser or TypeScript transformer.
+2. The SQL compiler turns IR into dialect-specific, parameterized SQL.
+3. The driver executes SQL through SQLite, PostgreSQL, or a custom backend.
+
+See the [Architecture reference](docs/reference/architecture.md).
+
+## Documentation
+
+- [Getting Started](docs/guide/getting-started.md)
+- [TypeScript Transformer](docs/guide/typescript-transformer.md)
+- [Entities & Relations](docs/guide/entities-relations.md)
+- [Querying Relations](docs/guide/querying-relations.md)
+- [Filtering by Relations](docs/guide/filtering-by-relations.md)
+- [Expressions](docs/guide/expressions.md)
+- [Aggregations](docs/guide/aggregations.md)
+- [Subqueries](docs/guide/subqueries.md)
+- [CTEs and Unions](docs/guide/cte-and-unions.md)
+- [Bulk Operations](docs/guide/bulk-operations.md)
+- [Transactions](docs/guide/transactions.md)
+- [Migrations](docs/migrations/overview.md)
+- [SQLite Driver](docs/drivers/sqlite.md)
+- [PostgreSQL Driver](docs/drivers/postgres.md)
+- [API Reference](docs/reference/api.md)
+
+## Contributing
+
+Contributions welcome. Open areas include:
+
+- Additional database drivers
+- Broader runtime predicate syntax
+- Runtime support for transformer-only scalar subquery shapes
+
+## License
+
+MIT

package/SECURITY.md

@@ -0,0 +1,32 @@
+# Security Policy
+
+## Supported versions
+
+Security fixes are applied to the latest release on the default branch (`main`). Older versions may not receive patches.
+
+| Version          | Supported   |
+| ---------------- | ----------- |
+| latest on `main` | yes         |
+| older tags       | best effort |
+
+## Reporting a vulnerability
+
+**Do not open a public GitHub issue for security vulnerabilities.**
+
+Instead, report them privately using one of these options:
+
+1. **GitHub private vulnerability reporting** (preferred): open the [Security tab](https://github.com/kalyvasio/typhex/security) on the repository and choose **Report a vulnerability**.
+2. If private reporting is unavailable, contact the repository owner through GitHub and ask for a secure channel.
+
+Please include:
+
+- A description of the issue and its impact
+- Steps to reproduce, or a minimal proof of concept if you have one
+- Affected versions or commits
+- Any suggested fix, if you have one
+
+We will acknowledge your report as soon as possible and keep you updated on remediation progress. Please allow reasonable time for a fix before public disclosure.
+
+## Safe harbor
+
+We appreciate responsible disclosure. We will not pursue legal action against researchers who report vulnerabilities in good faith and follow this policy.

package/dist/arrow/aggregates.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Canonical aggregate function names and normalization from JS stub
+ * identifiers (e.g. `groupConcat`) to IR func names (`GROUP_CONCAT`).
+ * Shared by runtime parser and compile-time transformer.
+ */
+/** Recognized aggregate function names in IR. */
+export declare const AGGREGATE_FUNCS: Set<string>;
+/** Map a JS identifier (e.g. `count`, `groupConcat`) to the canonical IR func name. */
+export declare function toIrFuncName(rawName: string): string;
+/** True if `name` is a known aggregate after normalization. */
+export declare function isAggregateFunc(name: string): boolean;
+//# sourceMappingURL=aggregates.d.ts.map

package/dist/arrow/aggregates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregates.d.ts","sourceRoot":"","sources":["../../src/arrow/aggregates.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,iDAAiD;AACjD,eAAO,MAAM,eAAe,aAU1B,CAAC;AASH,uFAAuF;AACvF,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,+DAA+D;AAC/D,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD"}

package/dist/arrow/aggregates.js

@@ -0,0 +1,32 @@
+/**
+ * Canonical aggregate function names and normalization from JS stub
+ * identifiers (e.g. `groupConcat`) to IR func names (`GROUP_CONCAT`).
+ * Shared by runtime parser and compile-time transformer.
+ */
+/** Recognized aggregate function names in IR. */
+export const AGGREGATE_FUNCS = new Set([
+    "SUM",
+    "AVG",
+    "MIN",
+    "MAX",
+    "COUNT",
+    "GROUP_CONCAT",
+    "STRING_AGG",
+    "ARRAY_AGG",
+    "JSON_AGG",
+]);
+const AGGREGATE_FUNC_MAP = {
+    groupconcat: "GROUP_CONCAT",
+    stringagg: "STRING_AGG",
+    arrayagg: "ARRAY_AGG",
+    jsonagg: "JSON_AGG",
+};
+/** Map a JS identifier (e.g. `count`, `groupConcat`) to the canonical IR func name. */
+export function toIrFuncName(rawName) {
+    return AGGREGATE_FUNC_MAP[rawName.toLowerCase()] ?? rawName.toUpperCase();
+}
+/** True if `name` is a known aggregate after normalization. */
+export function isAggregateFunc(name) {
+    return AGGREGATE_FUNCS.has(toIrFuncName(name));
+}
+//# sourceMappingURL=aggregates.js.map

package/dist/arrow/aggregates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregates.js","sourceRoot":"","sources":["../../src/arrow/aggregates.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,iDAAiD;AACjD,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,GAAG,CAAC;IACrC,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,OAAO;IACP,cAAc;IACd,YAAY;IACZ,WAAW;IACX,UAAU;CACX,CAAC,CAAC;AAEH,MAAM,kBAAkB,GAA2B;IACjD,WAAW,EAAE,cAAc;IAC3B,SAAS,EAAE,YAAY;IACvB,QAAQ,EAAE,WAAW;IACrB,OAAO,EAAE,UAAU;CACpB,CAAC;AAEF,uFAAuF;AACvF,MAAM,UAAU,YAAY,CAAC,OAAe;IAC1C,OAAO,kBAAkB,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;AAC5E,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,OAAO,eAAe,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;AACjD,CAAC"}

package/dist/arrow/constants.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared arrow-expression rules used by both the runtime parser (acorn) and
+ * the compile-time TypeScript transformer. Keeps allowed methods, default
+ * param names, and relation-chain method names in one place.
+ */
+import type { IrBinary } from "../ir/types.js";
+/** Default row parameter when inference fails (e.g. `u => …`). */
+export declare const DEFAULT_ROW_PARAM = "u";
+/** String methods permitted in WHERE predicates (receiver must be a member path). */
+export declare const ALLOWED_METHODS: Set<string>;
+/** Methods allowed on relation query chains inside select lambdas. */
+export declare const RELATION_QUERY_METHODS: Set<string>;
+/** Acorn binary/logical operator strings → IR binary ops (runtime parser only). */
+export declare const ACORN_BINARY_OPS: Record<string, IrBinary["op"] | undefined>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/arrow/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/arrow/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,kEAAkE;AAClE,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAErC,qFAAqF;AACrF,eAAO,MAAM,eAAe,aAAkD,CAAC;AAE/E,sEAAsE;AACtE,eAAO,MAAM,sBAAsB,aAOjC,CAAC;AAEH,mFAAmF;AACnF,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,SAAS,CAqBvE,CAAC"}

package/dist/arrow/constants.js

@@ -0,0 +1,42 @@
+/**
+ * Shared arrow-expression rules used by both the runtime parser (acorn) and
+ * the compile-time TypeScript transformer. Keeps allowed methods, default
+ * param names, and relation-chain method names in one place.
+ */
+/** Default row parameter when inference fails (e.g. `u => …`). */
+export const DEFAULT_ROW_PARAM = "u";
+/** String methods permitted in WHERE predicates (receiver must be a member path). */
+export const ALLOWED_METHODS = new Set(["startsWith", "endsWith", "includes"]);
+/** Methods allowed on relation query chains inside select lambdas. */
+export const RELATION_QUERY_METHODS = new Set([
+    "query",
+    "where",
+    "orderBy",
+    "limit",
+    "offset",
+    "select",
+]);
+/** Acorn binary/logical operator strings → IR binary ops (runtime parser only). */
+export const ACORN_BINARY_OPS = {
+    "&&": "&&",
+    "||": "||",
+    "==": "==",
+    "===": "===",
+    "!=": "!=",
+    "!==": "!==",
+    ">": ">",
+    ">=": ">=",
+    "<": "<",
+    "<=": "<=",
+    "+": "+",
+    "-": "-",
+    "*": "*",
+    "/": "/",
+    "%": "%",
+    "&": "&",
+    "|": "|",
+    "^": "^",
+    "<<": "<<",
+    ">>": ">>",
+};
+//# sourceMappingURL=constants.js.map

package/dist/arrow/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/arrow/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,kEAAkE;AAClE,MAAM,CAAC,MAAM,iBAAiB,GAAG,GAAG,CAAC;AAErC,qFAAqF;AACrF,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,GAAG,CAAC,CAAC,YAAY,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;AAE/E,sEAAsE;AACtE,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,GAAG,CAAC;IAC5C,OAAO;IACP,OAAO;IACP,SAAS;IACT,OAAO;IACP,QAAQ;IACR,QAAQ;CACT,CAAC,CAAC;AAEH,mFAAmF;AACnF,MAAM,CAAC,MAAM,gBAAgB,GAA+C;IAC1E,IAAI,EAAE,IAAI;IACV,IAAI,EAAE,IAAI;IACV,IAAI,EAAE,IAAI;IACV,KAAK,EAAE,KAAK;IACZ,IAAI,EAAE,IAAI;IACV,KAAK,EAAE,KAAK;IACZ,GAAG,EAAE,GAAG;IACR,IAAI,EAAE,IAAI;IACV,GAAG,EAAE,GAAG;IACR,IAAI,EAAE,IAAI;IACV,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,IAAI,EAAE,IAAI;IACV,IAAI,EAAE,IAAI;CACX,CAAC"}

package/dist/arrow/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Barrel re-export for shared arrow-expression language rules (constants,
+ * aggregate naming). Imported by `src/parser/*` and `src/transformer/*`.
+ */
+export { DEFAULT_ROW_PARAM, ALLOWED_METHODS, RELATION_QUERY_METHODS, ACORN_BINARY_OPS, } from "./constants.js";
+export { AGGREGATE_FUNCS, toIrFuncName, isAggregateFunc } from "./aggregates.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/arrow/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/arrow/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/arrow/index.js

@@ -0,0 +1,7 @@
+/**
+ * Barrel re-export for shared arrow-expression language rules (constants,
+ * aggregate naming). Imported by `src/parser/*` and `src/transformer/*`.
+ */
+export { DEFAULT_ROW_PARAM, ALLOWED_METHODS, RELATION_QUERY_METHODS, ACORN_BINARY_OPS, } from "./constants.js";
+export { AGGREGATE_FUNCS, toIrFuncName, isAggregateFunc } from "./aggregates.js";
+//# sourceMappingURL=index.js.map

package/dist/arrow/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/arrow/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/config/index.d.ts

@@ -0,0 +1,6 @@
+export type { TyphexConfig } from "./types.js";
+export { DEFAULT_CONFIG } from "./types.js";
+export { loadConfig } from "./load-config.js";
+export type { LoadConfigOptions } from "./load-config.js";
+export { loadTyphexEnv, envToConfig } from "./load-env.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,YAAY,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/dist/config/index.js

@@ -0,0 +1,4 @@
+export { DEFAULT_CONFIG } from "./types.js";
+export { loadConfig } from "./load-config.js";
+export { loadTyphexEnv, envToConfig } from "./load-env.js";
+//# sourceMappingURL=index.js.map

package/dist/config/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/dist/config/load-config.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Load typhex config from file or discover in cwd.
+ * Resolution: explicit path > typhex.config.js > typhex.config.mjs > typhex.config.json
+ */
+import type { TyphexConfig } from "./types.js";
+/** Options for `loadConfig`. All fields are optional; omit to use auto-discovery. */
+export interface LoadConfigOptions {
+    /** Explicit config file path */
+    configPath?: string;
+    /** Working directory for discovery */
+    cwd?: string;
+    /** Overrides (e.g. from CLI args) */
+    overrides?: Partial<TyphexConfig>;
+}
+/**
+ * Load and merge config. Order: overrides > config file > .env > defaults.
+ */
+export declare function loadConfig(options?: LoadConfigOptions): Promise<TyphexConfig>;
+//# sourceMappingURL=load-config.d.ts.map