synalog 2.0.0__tar.gz → 2.2.0__tar.gz

{synalog-2.0.0 → synalog-2.2.0}/Cargo.lock

@@ -2348,7 +2348,7 @@ dependencies = [
 
 [[package]]
 name = "synalog"
-version = "2.0.0"
+version = "2.2.0"
 dependencies = [
  "anyhow",
  "duckdb",

{synalog-2.0.0 → synalog-2.2.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "synalog"
-version = "2.0.0"
+version = "2.2.0"
 edition = "2024"
 description = "Logic programming for AI agents: Datalog-family language compiling to optimized SQL"
 license = "Apache-2.0"

{synalog-2.0.0 → synalog-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synalog
-Version: 2.0.0
+Version: 2.2.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: 3
@@ -162,13 +162,13 @@ $ synalog program.l run EngineeringTeam
 - `--limit` / `--offset` paginate the result.
 - `--csv` (with `run`) prints results as CSV instead of the rendered table.
 - `--search REGEX` (with `print`/`run`) keeps only rows where some column matches the regular expression `REGEX`, e.g. `synalog program.l run Customers --search "(?i)acme"`. In the interactive session the same is `.search Customers (?i)acme`.
-- `run` executes on `duckdb` (the default), `sqlite` (stdlib) or `psql` (with `--dsn` or `SYNALOG_PSQL_DSN`) out of the box: synalog depends on duckdb and on psycopg with its bundled libpq, on macOS and Linux alike. For other engines, install their driver (`pip install 'synalog[trino]'`, ...) or use `print` and run the SQL with your own client.
+- `run` executes on `duckdb` (the default), `sqlite` (stdlib) or `psql` (in a [project](#projects-layertoml) connected to it) out of the box: synalog depends on duckdb and on psycopg with its bundled libpq, on macOS and Linux alike. For other engines, install their driver (`pip install 'synalog[trino]'`, ...) or use `print` and run the SQL with your own client.
 - `import path.to.file.Pred;` statements resolve `path/to/file.l` against the program file's directory, then the current directory; pass `--import-root DIR` (repeatable) to search elsewhere.
 - `--load TABLE=PATH` (repeatable) loads a csv/tsv/json/jsonl/parquet file as a table before running, e.g. `synalog senior.l run Senior --load employees=employees.csv`.
 
-### Projects: `synalog.toml`
+### Projects: `layer.toml`
 
-A folder with a `synalog.toml` is a project. Its `[connection]` says which database its programs run on, as plain fields — commit it:
+A folder with a `layer.toml` is a project. Its `[connection]` says which database its programs run on, as plain fields — commit it:
 
 ```toml
 [connection]
@@ -180,7 +180,7 @@ user = "analyst"
 schema = "public"
 ```
 
-Secrets never go in the file (synalog refuses it): each comes from the environment as `SYNALOG_<ENGINE>_<FIELD>` — `SYNALOG_PSQL_PASSWORD`, `SYNALOG_DATABRICKS_ACCESS_TOKEN`, or `GOOGLE_APPLICATION_CREDENTIALS` for BigQuery — usually from the project's `.env`, kept out of git. Inside the project (from the program's folder or the current directory, and their parents), `run`, `print` and `verify` use that engine and connection, imports resolve from the project's folder, and `synalog introspect` writes the project's `tables/`, one file per table of the database; `--engine`, an `@Engine` annotation, `--dsn` and `SYNALOG_<ENGINE>_DSN` still take precedence. The fields of every engine are in `synalog.project.ENGINES`.
+Secrets never go in the file (synalog refuses it): each comes from the environment as `SYNALOG_<ENGINE>_<FIELD>` — `SYNALOG_PSQL_PASSWORD`, `SYNALOG_DATABRICKS_ACCESS_TOKEN`, or `GOOGLE_APPLICATION_CREDENTIALS` for BigQuery — usually from the project's `.env`, kept out of git. Inside the project (from the program's folder or the current directory, and their parents), `run`, `print` and `verify` use that engine and connection, imports resolve from the project's folder, and `synalog introspect` writes the project's `tables/`, one file per table of the database. The project's file is the only place a connection comes from; `--engine` and an `@Engine` annotation choose the dialect, and a remote engine runs only through the project's connection to it. `synalog connect <engine> key=value ...` writes it — the non-secret fields to `layer.toml`, the secret ones to `.env` — `synalog connect` shows it (secrets hidden), `synalog connect clear` removes it. The fields of every engine are in `synalog.project.ENGINES`.
 
 Running `synalog` with no arguments starts an interactive session, in the spirit of `python` (the options above, e.g. `--engine` or `--load`, apply to it too):
 
@@ -262,7 +262,7 @@ for name, sql in sqls.items():
     print(name, sql)
 ```
 
-### `execute(source, predicate, engine=None, dsn=None, import_root=None, limit=None, offset=None, pattern=None, assertion=None, loads=()) -> tuple[list[str], list[tuple]]`
+### `execute(source, predicate, engine=None, project=None, import_root=None, limit=None, offset=None, pattern=None, assertion=None, loads=()) -> tuple[list[str], list[tuple]]`
 
 Run a predicate on its database (the program's or project's engine and connection) and return `(columns, rows)`. Each recursion stops as soon as a step changes nothing, so it costs the steps its data needs, and `@Recursive(P, -1)` (until nothing changes) runs on every engine. `plan()` returns the same steps for a host that runs them itself.
 
@@ -270,9 +270,9 @@ Run a predicate on its database (the program's or project's engine and connectio
 columns, rows = synalog.execute(source, "TopCustomers", limit=20)
 ```
 
-### `check(source, engine=None, import_root=None, assertions=True, dsn=None) -> tuple[list[str], list[str]]`
+### `check(source, engine=None, import_root=None, assertions=True, project=None) -> tuple[list[str], list[str]]`
 
-Run structural validation. Returns the error messages and the warning messages, as two lists. The program is valid when there is no error; warnings do not make it invalid. Inside a project whose `synalog.toml` has a `[connection]` (or given a `dsn`), it also runs the program's `@Assert` statements against the database and reports each violated one as an error; `assertions=False` keeps it offline.
+Run structural validation. Returns the error messages and the warning messages, as two lists. The program is valid when there is no error; warnings do not make it invalid. Inside a project whose `layer.toml` has a `[connection]` — the current directory's, or the folder `project` names — it also runs the program's `@Assert` statements against the database and reports each violated one as an error; `assertions=False` keeps it offline.
 
 ```python
 errors, warnings = synalog.check(source)
@@ -285,22 +285,22 @@ All of these functions accept an optional `engine` keyword that overrides the pr
 
 ## Language overview
 
-A Synalog program is a **project**: a folder with a `synalog.toml`, holding one predicate per file in three folders, the layout of [semantic layers](https://github.com/SynaLinks/semantic-layers):
+A Synalog program is a **project**: a folder with a `layer.toml`, holding one predicate per file in three folders, the layout of [semantic layers](https://github.com/SynaLinks/semantic-layers):
 
 ```
 shop/
-├── tables/Orders.l               # the data: one file per database table
-├── concepts/Customer.l           # entities and relationships extracted from tables
-├── rules/CustomerRevenue.l       # insights derived from concepts
-├── rules/TopCustomers.l
-└── synalog.toml                  # the project's name, description and database
+├── tables/orders.l               # the data: one file per database table
+├── concepts/customer.l           # entities and relationships extracted from tables
+├── rules/customer_revenue.l       # insights derived from concepts
+├── rules/top_customers.l
+└── layer.toml                    # the project's name, description and database
 ```
 
 Each file is named after its predicate and opens with front matter (`name`, the predicate; `description`, what its rows are), then imports what it builds on by folder, file and predicate, then orders its predicate with `@OrderBy`. A database table is referenced by its lowercase database name in `tables/`, and everything else builds on the PascalCase predicate that maps it:
 
-`tables/Orders.l`
+`tables/orders.l`
 
-```logica
+```synalog
 ---
 name: Orders
 description: One row per order, with its customer, amount and status.
@@ -310,41 +310,41 @@ Orders(order_id:, customer_id:, amount:, status:) :-
   orders(order_id:, customer_id:, amount:, status:);
 ```
 
-`concepts/Customer.l`
+`concepts/customer.l`
 
-```logica
+```synalog
 ---
 name: Customer
 description: Every customer who placed at least one order.
 ---
-import tables.Orders.Orders;
+import tables.orders.Orders;
 
 @OrderBy(Customer, "customer_id");
 Customer(customer_id:) distinct :- Orders(customer_id:);
 ```
 
-`rules/CustomerRevenue.l`
+`rules/customer_revenue.l`
 
-```logica
+```synalog
 ---
 name: CustomerRevenue
 description: Total amount ordered by each customer, all statuses included.
 ---
-import concepts.Customer.Customer;
-import tables.Orders.Orders;
+import concepts.customer.Customer;
+import tables.orders.Orders;
 
 @OrderBy(CustomerRevenue, "customer_id");
 CustomerRevenue(customer_id:, total? += amount) distinct :-
   Customer(customer_id:), Orders(customer_id:, amount:);
 ```
 
-Imports resolve from the project's folder, so every file runs on its own: `synalog rules/CustomerRevenue.l run CustomerRevenue`. The snippets below show the language itself, one rule at a time.
+Imports resolve from the project's folder, so every file runs on its own: `synalog rules/customer_revenue.l run CustomerRevenue`. The snippets below show the language itself, one rule at a time.
 
 ### Named arguments
 
 Synalog uses **named arguments only** (no positional arguments). The left side of `:` is the column name, the right side is the variable:
 
-```logica
+```synalog
 # column "amount" bound to variable "total"
 Orders(amount: total)
 
@@ -356,7 +356,7 @@ Orders(amount:)
 
 Variables are defined with `==`. Arithmetic, string and comparison operators are supported:
 
-```logica
+```synalog
 OrderWithTax(order_id:, total:) :-
   Orders(order_id:, amount:),
   total == amount * 1.10;
@@ -368,7 +368,7 @@ OrderWithTax(order_id:, total:) :-
 
 Aggregation uses the `distinct` keyword and special operators in the rule head:
 
-```logica
+```synalog
 # Sum
 Revenue(total? += amount) distinct :- Orders(amount:);
 
@@ -392,7 +392,7 @@ TopSeller(name? ArgMax= name -> revenue) distinct :- Sales(name:, revenue:);
 
 ### Logical operators
 
-```logica
+```synalog
 # Conjunction (AND), comma
 Result(x:, y:) :- TableA(x:), TableB(x:, y:);
 
@@ -405,14 +405,14 @@ Inactive(user_id:) :- Users(user_id:), ~Logins(user_id:);
 
 Multiple rule definitions for the same predicate combine results (union):
 
-```logica
+```synalog
 HighValue(user_id:) :- Orders(user_id:, amount:), amount > 10000;
 HighValue(user_id:) :- Referrals(user_id:, tier: "vip");
 ```
 
 ### Conditionals
 
-```logica
+```synalog
 OrderSize(order_id:, size:) :-
   Orders(order_id:, amount:),
   size == (if amount > 1000 then "large"
@@ -424,7 +424,7 @@ OrderSize(order_id:, size:) :-
 
 Directives control predicate behavior and **must be placed before** the rule definition:
 
-```logica
+```synalog
 @OrderBy(TopCustomers, "total", "DESC");
 @Limit(TopCustomers, 10);
 TopCustomers(customer_id:, total? += amount) distinct :- Orders(customer_id:, amount:);
@@ -442,7 +442,7 @@ TopCustomers(customer_id:, total? += amount) distinct :- Orders(customer_id:, am
 
 Functors let you reuse predicate logic by parameterizing input predicates:
 
-```logica
+```synalog
 # Define a reusable pattern
 @OrderBy(SegmentRevenue, "segment_id");
 SegmentRevenue(segment_id:, total? += amount) distinct :-
@@ -458,7 +458,7 @@ SMBRevenue := SegmentRevenue(Segment: SMBCustomers);
 
 Recursive predicates compute transitive closures, for example finding all managers above an employee:
 
-```logica
+```synalog
 @Recursive(AllManagers, 20);
 
 # Base case: direct manager
@@ -476,7 +476,7 @@ Useful for: referral chains, org charts, product taxonomies, bill of materials.
 
 Find shortest paths in weighted graphs by enumerating route costs recursively, then keeping the minimum per destination with a `Min=` aggregation:
 
-```logica
+```synalog
 # Enumerate route costs from the origin, hop by hop.
 @Recursive(RouteCost, 10);
 RouteCost(destination:, cost:) :-
@@ -495,7 +495,7 @@ ShippingCost(destination:, total? Min= cost) distinct :- RouteCost(destination:,
 
 When working with timestamps or dates, always convert to string first:
 
-```logica
+```synalog
 @OrderBy(MonthlyOrders, "month");
 MonthlyOrders(month:, count? += 1) distinct :-
   Orders(created_at:),
@@ -509,7 +509,7 @@ RecentOrders(order_id:) :-
 
 `Today(date:)` (today's date as `"YYYY-MM-DD"`) and `Now(timestamp:)` (the current instant as the engine's native timestamp) are built-in concepts. They are inlined per dialect by the compiler, with no runtime table needed, so they work on every engine. `Now` is the most precise value; derive coarser parts (date, time, hour) from it through the `ToString` → `Substr` pipeline. Join against `Today` whenever a rule needs "today":
 
-```logica
+```synalog
 @OrderBy(ThisMonthOrders, "order_id");
 ThisMonthOrders(order_id:, created_at:) :-
   Orders(order_id:, created_at:),
@@ -523,7 +523,7 @@ They are reserved names: you cannot redefine, extend, or update them.
 
 Entities and relationships become node and edge concepts, and rules traverse them. Edges join **through** the node concepts rather than the raw table, so a filter on a node applies to every edge built on it:
 
-```logica
+```synalog
 @OrderBy(Person, "person_id");
 Person(person_id:, name:, profile_url:) distinct :- Employees(person_id:, name:, profile_url:);
 
@@ -536,7 +536,7 @@ WorksIn(person_id:, department_id:) distinct :-
 
 Relationships with a lifetime carry it as a half-open interval `[valid_from, valid_to)`, using `"9999-12-31"` as the open end so ISO strings compare correctly, and `Today` supplies the clock for point-in-time questions:
 
-```logica
+```synalog
 @OrderBy(CurrentEmployment, "person_id");
 CurrentEmployment(person_id:, company_id:, role:) distinct :-
   EmployedAt(person_id:, company_id:, role:, valid_from:, valid_to:),

{synalog-2.0.0 → synalog-2.2.0}/README.md

@@ -120,13 +120,13 @@ $ synalog program.l run EngineeringTeam
 - `--limit` / `--offset` paginate the result.
 - `--csv` (with `run`) prints results as CSV instead of the rendered table.
 - `--search REGEX` (with `print`/`run`) keeps only rows where some column matches the regular expression `REGEX`, e.g. `synalog program.l run Customers --search "(?i)acme"`. In the interactive session the same is `.search Customers (?i)acme`.
-- `run` executes on `duckdb` (the default), `sqlite` (stdlib) or `psql` (with `--dsn` or `SYNALOG_PSQL_DSN`) out of the box: synalog depends on duckdb and on psycopg with its bundled libpq, on macOS and Linux alike. For other engines, install their driver (`pip install 'synalog[trino]'`, ...) or use `print` and run the SQL with your own client.
+- `run` executes on `duckdb` (the default), `sqlite` (stdlib) or `psql` (in a [project](#projects-layertoml) connected to it) out of the box: synalog depends on duckdb and on psycopg with its bundled libpq, on macOS and Linux alike. For other engines, install their driver (`pip install 'synalog[trino]'`, ...) or use `print` and run the SQL with your own client.
 - `import path.to.file.Pred;` statements resolve `path/to/file.l` against the program file's directory, then the current directory; pass `--import-root DIR` (repeatable) to search elsewhere.
 - `--load TABLE=PATH` (repeatable) loads a csv/tsv/json/jsonl/parquet file as a table before running, e.g. `synalog senior.l run Senior --load employees=employees.csv`.
 
-### Projects: `synalog.toml`
+### Projects: `layer.toml`
 
-A folder with a `synalog.toml` is a project. Its `[connection]` says which database its programs run on, as plain fields — commit it:
+A folder with a `layer.toml` is a project. Its `[connection]` says which database its programs run on, as plain fields — commit it:
 
 ```toml
 [connection]
@@ -138,7 +138,7 @@ user = "analyst"
 schema = "public"
 ```
 
-Secrets never go in the file (synalog refuses it): each comes from the environment as `SYNALOG_<ENGINE>_<FIELD>` — `SYNALOG_PSQL_PASSWORD`, `SYNALOG_DATABRICKS_ACCESS_TOKEN`, or `GOOGLE_APPLICATION_CREDENTIALS` for BigQuery — usually from the project's `.env`, kept out of git. Inside the project (from the program's folder or the current directory, and their parents), `run`, `print` and `verify` use that engine and connection, imports resolve from the project's folder, and `synalog introspect` writes the project's `tables/`, one file per table of the database; `--engine`, an `@Engine` annotation, `--dsn` and `SYNALOG_<ENGINE>_DSN` still take precedence. The fields of every engine are in `synalog.project.ENGINES`.
+Secrets never go in the file (synalog refuses it): each comes from the environment as `SYNALOG_<ENGINE>_<FIELD>` — `SYNALOG_PSQL_PASSWORD`, `SYNALOG_DATABRICKS_ACCESS_TOKEN`, or `GOOGLE_APPLICATION_CREDENTIALS` for BigQuery — usually from the project's `.env`, kept out of git. Inside the project (from the program's folder or the current directory, and their parents), `run`, `print` and `verify` use that engine and connection, imports resolve from the project's folder, and `synalog introspect` writes the project's `tables/`, one file per table of the database. The project's file is the only place a connection comes from; `--engine` and an `@Engine` annotation choose the dialect, and a remote engine runs only through the project's connection to it. `synalog connect <engine> key=value ...` writes it — the non-secret fields to `layer.toml`, the secret ones to `.env` — `synalog connect` shows it (secrets hidden), `synalog connect clear` removes it. The fields of every engine are in `synalog.project.ENGINES`.
 
 Running `synalog` with no arguments starts an interactive session, in the spirit of `python` (the options above, e.g. `--engine` or `--load`, apply to it too):
 
@@ -220,7 +220,7 @@ for name, sql in sqls.items():
     print(name, sql)
 ```
 
-### `execute(source, predicate, engine=None, dsn=None, import_root=None, limit=None, offset=None, pattern=None, assertion=None, loads=()) -> tuple[list[str], list[tuple]]`
+### `execute(source, predicate, engine=None, project=None, import_root=None, limit=None, offset=None, pattern=None, assertion=None, loads=()) -> tuple[list[str], list[tuple]]`
 
 Run a predicate on its database (the program's or project's engine and connection) and return `(columns, rows)`. Each recursion stops as soon as a step changes nothing, so it costs the steps its data needs, and `@Recursive(P, -1)` (until nothing changes) runs on every engine. `plan()` returns the same steps for a host that runs them itself.
 
@@ -228,9 +228,9 @@ Run a predicate on its database (the program's or project's engine and connectio
 columns, rows = synalog.execute(source, "TopCustomers", limit=20)
 ```
 
-### `check(source, engine=None, import_root=None, assertions=True, dsn=None) -> tuple[list[str], list[str]]`
+### `check(source, engine=None, import_root=None, assertions=True, project=None) -> tuple[list[str], list[str]]`
 
-Run structural validation. Returns the error messages and the warning messages, as two lists. The program is valid when there is no error; warnings do not make it invalid. Inside a project whose `synalog.toml` has a `[connection]` (or given a `dsn`), it also runs the program's `@Assert` statements against the database and reports each violated one as an error; `assertions=False` keeps it offline.
+Run structural validation. Returns the error messages and the warning messages, as two lists. The program is valid when there is no error; warnings do not make it invalid. Inside a project whose `layer.toml` has a `[connection]` — the current directory's, or the folder `project` names — it also runs the program's `@Assert` statements against the database and reports each violated one as an error; `assertions=False` keeps it offline.
 
 ```python
 errors, warnings = synalog.check(source)
@@ -243,22 +243,22 @@ All of these functions accept an optional `engine` keyword that overrides the pr
 
 ## Language overview
 
-A Synalog program is a **project**: a folder with a `synalog.toml`, holding one predicate per file in three folders, the layout of [semantic layers](https://github.com/SynaLinks/semantic-layers):
+A Synalog program is a **project**: a folder with a `layer.toml`, holding one predicate per file in three folders, the layout of [semantic layers](https://github.com/SynaLinks/semantic-layers):
 
 ```
 shop/
-├── tables/Orders.l               # the data: one file per database table
-├── concepts/Customer.l           # entities and relationships extracted from tables
-├── rules/CustomerRevenue.l       # insights derived from concepts
-├── rules/TopCustomers.l
-└── synalog.toml                  # the project's name, description and database
+├── tables/orders.l               # the data: one file per database table
+├── concepts/customer.l           # entities and relationships extracted from tables
+├── rules/customer_revenue.l       # insights derived from concepts
+├── rules/top_customers.l
+└── layer.toml                    # the project's name, description and database
 ```
 
 Each file is named after its predicate and opens with front matter (`name`, the predicate; `description`, what its rows are), then imports what it builds on by folder, file and predicate, then orders its predicate with `@OrderBy`. A database table is referenced by its lowercase database name in `tables/`, and everything else builds on the PascalCase predicate that maps it:
 
-`tables/Orders.l`
+`tables/orders.l`
 
-```logica
+```synalog
 ---
 name: Orders
 description: One row per order, with its customer, amount and status.
@@ -268,41 +268,41 @@ Orders(order_id:, customer_id:, amount:, status:) :-
   orders(order_id:, customer_id:, amount:, status:);
 ```
 
-`concepts/Customer.l`
+`concepts/customer.l`
 
-```logica
+```synalog
 ---
 name: Customer
 description: Every customer who placed at least one order.
 ---
-import tables.Orders.Orders;
+import tables.orders.Orders;
 
 @OrderBy(Customer, "customer_id");
 Customer(customer_id:) distinct :- Orders(customer_id:);
 ```
 
-`rules/CustomerRevenue.l`
+`rules/customer_revenue.l`
 
-```logica
+```synalog
 ---
 name: CustomerRevenue
 description: Total amount ordered by each customer, all statuses included.
 ---
-import concepts.Customer.Customer;
-import tables.Orders.Orders;
+import concepts.customer.Customer;
+import tables.orders.Orders;
 
 @OrderBy(CustomerRevenue, "customer_id");
 CustomerRevenue(customer_id:, total? += amount) distinct :-
   Customer(customer_id:), Orders(customer_id:, amount:);
 ```
 
-Imports resolve from the project's folder, so every file runs on its own: `synalog rules/CustomerRevenue.l run CustomerRevenue`. The snippets below show the language itself, one rule at a time.
+Imports resolve from the project's folder, so every file runs on its own: `synalog rules/customer_revenue.l run CustomerRevenue`. The snippets below show the language itself, one rule at a time.
 
 ### Named arguments
 
 Synalog uses **named arguments only** (no positional arguments). The left side of `:` is the column name, the right side is the variable:
 
-```logica
+```synalog
 # column "amount" bound to variable "total"
 Orders(amount: total)
 
@@ -314,7 +314,7 @@ Orders(amount:)
 
 Variables are defined with `==`. Arithmetic, string and comparison operators are supported:
 
-```logica
+```synalog
 OrderWithTax(order_id:, total:) :-
   Orders(order_id:, amount:),
   total == amount * 1.10;
@@ -326,7 +326,7 @@ OrderWithTax(order_id:, total:) :-
 
 Aggregation uses the `distinct` keyword and special operators in the rule head:
 
-```logica
+```synalog
 # Sum
 Revenue(total? += amount) distinct :- Orders(amount:);
 
@@ -350,7 +350,7 @@ TopSeller(name? ArgMax= name -> revenue) distinct :- Sales(name:, revenue:);
 
 ### Logical operators
 
-```logica
+```synalog
 # Conjunction (AND), comma
 Result(x:, y:) :- TableA(x:), TableB(x:, y:);
 
@@ -363,14 +363,14 @@ Inactive(user_id:) :- Users(user_id:), ~Logins(user_id:);
 
 Multiple rule definitions for the same predicate combine results (union):
 
-```logica
+```synalog
 HighValue(user_id:) :- Orders(user_id:, amount:), amount > 10000;
 HighValue(user_id:) :- Referrals(user_id:, tier: "vip");
 ```
 
 ### Conditionals
 
-```logica
+```synalog
 OrderSize(order_id:, size:) :-
   Orders(order_id:, amount:),
   size == (if amount > 1000 then "large"
@@ -382,7 +382,7 @@ OrderSize(order_id:, size:) :-
 
 Directives control predicate behavior and **must be placed before** the rule definition:
 
-```logica
+```synalog
 @OrderBy(TopCustomers, "total", "DESC");
 @Limit(TopCustomers, 10);
 TopCustomers(customer_id:, total? += amount) distinct :- Orders(customer_id:, amount:);
@@ -400,7 +400,7 @@ TopCustomers(customer_id:, total? += amount) distinct :- Orders(customer_id:, am
 
 Functors let you reuse predicate logic by parameterizing input predicates:
 
-```logica
+```synalog
 # Define a reusable pattern
 @OrderBy(SegmentRevenue, "segment_id");
 SegmentRevenue(segment_id:, total? += amount) distinct :-
@@ -416,7 +416,7 @@ SMBRevenue := SegmentRevenue(Segment: SMBCustomers);
 
 Recursive predicates compute transitive closures, for example finding all managers above an employee:
 
-```logica
+```synalog
 @Recursive(AllManagers, 20);
 
 # Base case: direct manager
@@ -434,7 +434,7 @@ Useful for: referral chains, org charts, product taxonomies, bill of materials.
 
 Find shortest paths in weighted graphs by enumerating route costs recursively, then keeping the minimum per destination with a `Min=` aggregation:
 
-```logica
+```synalog
 # Enumerate route costs from the origin, hop by hop.
 @Recursive(RouteCost, 10);
 RouteCost(destination:, cost:) :-
@@ -453,7 +453,7 @@ ShippingCost(destination:, total? Min= cost) distinct :- RouteCost(destination:,
 
 When working with timestamps or dates, always convert to string first:
 
-```logica
+```synalog
 @OrderBy(MonthlyOrders, "month");
 MonthlyOrders(month:, count? += 1) distinct :-
   Orders(created_at:),
@@ -467,7 +467,7 @@ RecentOrders(order_id:) :-
 
 `Today(date:)` (today's date as `"YYYY-MM-DD"`) and `Now(timestamp:)` (the current instant as the engine's native timestamp) are built-in concepts. They are inlined per dialect by the compiler, with no runtime table needed, so they work on every engine. `Now` is the most precise value; derive coarser parts (date, time, hour) from it through the `ToString` → `Substr` pipeline. Join against `Today` whenever a rule needs "today":
 
-```logica
+```synalog
 @OrderBy(ThisMonthOrders, "order_id");
 ThisMonthOrders(order_id:, created_at:) :-
   Orders(order_id:, created_at:),
@@ -481,7 +481,7 @@ They are reserved names: you cannot redefine, extend, or update them.
 
 Entities and relationships become node and edge concepts, and rules traverse them. Edges join **through** the node concepts rather than the raw table, so a filter on a node applies to every edge built on it:
 
-```logica
+```synalog
 @OrderBy(Person, "person_id");
 Person(person_id:, name:, profile_url:) distinct :- Employees(person_id:, name:, profile_url:);
 
@@ -494,7 +494,7 @@ WorksIn(person_id:, department_id:) distinct :-
 
 Relationships with a lifetime carry it as a half-open interval `[valid_from, valid_to)`, using `"9999-12-31"` as the open end so ISO strings compare correctly, and `Today` supplies the clock for point-in-time questions:
 
-```logica
+```synalog
 @OrderBy(CurrentEmployment, "person_id");
 CurrentEmployment(person_id:, company_id:, role:) distinct :-
   EmployedAt(person_id:, company_id:, role:, valid_from:, valid_to:),

{synalog-2.0.0 → synalog-2.2.0}/docs/assertions.md

@@ -9,7 +9,7 @@ Assertions are written in first-order logic, not in Synalog. A rule and its asse
 
 ## A first assertion
 
-```logica
+```synalog
 Parent(x:, y:) :- parents(parent: x, child: y);
 
 @Assert(Ancestor,
@@ -48,7 +48,7 @@ Carol is Alice's grandchild, Erin is Carol's, but Erin is Alice's great-grandchi
 
 `@Assert` takes the predicate the properties are about, then one named argument per property: the name identifies the property in reports, the string is the statement.
 
-```logica
+```synalog
 @Assert(Revenue,
       one_row_per_customer: "∀ c r s, Revenue c r → Revenue c s → r = s",
       positive:             "∀ c, Revenue c > 0");
@@ -57,6 +57,7 @@ Carol is Alice's grandchild, Erin is Carol's, but Erin is Alice's great-grandchi
 - A predicate may have several `@Assert` annotations; a name may appear only once per predicate.
 - A statement that spans several lines goes in a triple-quoted string (`"""..."""`).
 - An assertion can be written before its predicate exists: it waits, as `pending`, until the predicate is defined. Write the contract first.
+- Once its predicate exists, an assertion naming a predicate that nothing defines or imports is a warning: a misspelled name, or a missing import, would leave it pending, never checked.
 - Assertions do not change the generated SQL.
 
 ## The statement language
@@ -74,7 +75,7 @@ Statements are written as [Lean](https://lean-lang.org/) propositions, with the
 | `+`, `-`, `*`, `/` | | arithmetic |
 | `∑ x, t` | `sum x, t` | sum of `t` over `x` |
 
-```logica
+```synalog
 @Assert(Revenue, consistent: """forall c r s,
                                 Revenue c r -> Revenue c s -> r = s""");
 ```
@@ -92,7 +93,7 @@ A name bound by a quantifier is a variable; an unbound lowercase name is univers
 
 The properties worth stating are the ones a rule can silently get wrong. All of these run as written against the tables `orders(order_id, customer_id, amount, status)` and `customers(customer_id, country)`:
 
-```logica
+```synalog
 Order(order_id:, customer_id:, amount:, status:) :- orders(order_id:, customer_id:, amount:, status:);
 Customer(customer_id:, country:) :- customers(customer_id:, country:);
 
@@ -143,7 +144,7 @@ An assertion is checked by looking for its counterexamples: Synalog compiles tha
 | `synalog program.l verify [Predicate ...]` | Runs every assertion, or those of the given predicates, and prints the counterexamples of each violated one (5 by default, `--limit` to change). Exits 1 if one is violated. |
 | `synalog program.l run Predicate` | Checks the program's assertions before it prints anything, and exits 1 with a few counterexamples if one is violated. |
 | `synalog program.l print Predicate` | Never touches the database: assertions are not run. |
-| [`check()`](python-api.md#check) | Runs the assertions when a database is known: inside a project whose `synalog.toml` has a `[connection]`, or given a `dsn`. Each violated assertion is an error. `assertions=False` keeps it offline. |
+| [`check()`](python-api.md#check) | Runs the assertions when a database is known: inside a project whose `layer.toml` has a `[connection]` (the current directory's, or the folder `project` names). Each violated assertion is an error. `assertions=False` keeps it offline. |
 
 ```text
 $ synalog family.l run Grandparent --load parents=parents.csv

synalog-2.2.0/docs/assets/synalog-dark.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" viewBox="0 0 100 100" role="img" aria-label="Synalog">
+  <title>Synalog</title>
+  <!-- A Hilbert curve of order 3: one line made of smaller copies of itself. -->
+  <defs>
+    <linearGradient id="synalog" gradientUnits="userSpaceOnUse" x1="14.86" y1="14.86" x2="85.14" y2="85.14">
+      <stop offset="0" stop-color="#f0e3fb"/>
+      <stop offset="1" stop-color="#a271d6"/>
+    </linearGradient>
+  </defs>
+  <path d="M14.86 14.86 L14.86 24.90 L24.90 24.90 L24.90 14.86 L34.94 14.86 L44.98 14.86 L44.98 24.90 L34.94 24.90 L34.94 34.94 L44.98 34.94 L44.98 44.98 L34.94 44.98 L24.90 44.98 L24.90 34.94 L14.86 34.94 L14.86 44.98 L14.86 55.02 L24.90 55.02 L24.90 65.06 L14.86 65.06 L14.86 75.10 L14.86 85.14 L24.90 85.14 L24.90 75.10 L34.94 75.10 L34.94 85.14 L44.98 85.14 L44.98 75.10 L44.98 65.06 L34.94 65.06 L34.94 55.02 L44.98 55.02 L55.02 55.02 L65.06 55.02 L65.06 65.06 L55.02 65.06 L55.02 75.10 L55.02 85.14 L65.06 85.14 L65.06 75.10 L75.10 75.10 L75.10 85.14 L85.14 85.14 L85.14 75.10 L85.14 65.06 L75.10 65.06 L75.10 55.02 L85.14 55.02 L85.14 44.98 L85.14 34.94 L75.10 34.94 L75.10 44.98 L65.06 44.98 L55.02 44.98 L55.02 34.94 L65.06 34.94 L65.06 24.90 L55.02 24.90 L55.02 14.86 L65.06 14.86 L75.10 14.86 L75.10 24.90 L85.14 24.90 L85.14 14.86" fill="none" stroke="url(#synalog)" stroke-width="5.71" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

synalog-2.2.0/docs/assets/synalog-light.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" viewBox="0 0 100 100" role="img" aria-label="Synalog">
+  <title>Synalog</title>
+  <!-- A Hilbert curve of order 3: one line made of smaller copies of itself. -->
+  <defs>
+    <linearGradient id="synalog" gradientUnits="userSpaceOnUse" x1="14.86" y1="14.86" x2="85.14" y2="85.14">
+      <stop offset="0" stop-color="#4e2275"/>
+      <stop offset="1" stop-color="#b07ddb"/>
+    </linearGradient>
+  </defs>
+  <path d="M14.86 14.86 L14.86 24.90 L24.90 24.90 L24.90 14.86 L34.94 14.86 L44.98 14.86 L44.98 24.90 L34.94 24.90 L34.94 34.94 L44.98 34.94 L44.98 44.98 L34.94 44.98 L24.90 44.98 L24.90 34.94 L14.86 34.94 L14.86 44.98 L14.86 55.02 L24.90 55.02 L24.90 65.06 L14.86 65.06 L14.86 75.10 L14.86 85.14 L24.90 85.14 L24.90 75.10 L34.94 75.10 L34.94 85.14 L44.98 85.14 L44.98 75.10 L44.98 65.06 L34.94 65.06 L34.94 55.02 L44.98 55.02 L55.02 55.02 L65.06 55.02 L65.06 65.06 L55.02 65.06 L55.02 75.10 L55.02 85.14 L65.06 85.14 L65.06 75.10 L75.10 75.10 L75.10 85.14 L85.14 85.14 L85.14 75.10 L85.14 65.06 L75.10 65.06 L75.10 55.02 L85.14 55.02 L85.14 44.98 L85.14 34.94 L75.10 34.94 L75.10 44.98 L65.06 44.98 L55.02 44.98 L55.02 34.94 L65.06 34.94 L65.06 24.90 L55.02 24.90 L55.02 14.86 L65.06 14.86 L75.10 14.86 L75.10 24.90 L85.14 24.90 L85.14 14.86" fill="none" stroke="url(#synalog)" stroke-width="5.71" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>