@jarenjs/linq 0.67.0 → 0.72.0

package/README.md

@@ -13,7 +13,8 @@ it by hand, as JSON, with nothing checking it until it ran.
 
 This package removes the price. You write the query, the schema, the
 model, the migration, the contract, the stylesheet, the state machine,
-the dataflow, the application or the form as ordinary typed JavaScript,
+the dataflow, the application, the form, chart, project, text template,
+message catalog or AI program as ordinary typed JavaScript,
 and what comes back is the document — exactly the one its engine
 already takes, byte for byte, with its types derived beside it. The
 chain is the pen; the document is the deliverable.
@@ -46,9 +47,11 @@ SQL — and nothing is hidden: the chain's `explain()` shows the document
 it sent, and the store's `explain(document)` shows what that became,
 `SELECT … FROM "User" WHERE "age" > ? ORDER BY "name"`.
 
+Coverage: <!--fact:coverage.pens-->14 public pen/client subpaths beside the chain; 69/69 owned schema keywords have dedicated emission routes.<!--/fact-->
+
 ## What you gain
 
-- **One idiom for ten kinds of document.** `(u) => u.age.gt(21)` is a
+- **One idiom across document formats.** `(u) => u.age.gt(21)` is a
   query predicate. The same shape is a schema's cross-field `check()`,
   a form's `assert`, a state machine's guard, a stylesheet rule's body,
   an app action's patch. Every callback is recorded by one proxy over
@@ -95,6 +98,11 @@ it sent, and the store's `explain(document)` shows what that became,
 | a state machine, a dataflow | `@jarenjs/linq/flow` | `@jarenjs/flow` | [flow pen](#by-code-the-flow-pen) · [FLOW-PEN](docs/FLOW-PEN.md) |
 | an application | `@jarenjs/linq/app` | `@jarenjs/app` | [app pen](#by-code-the-app-pen) · [APP-PEN](docs/APP-PEN.md) |
 | a form | `@jarenjs/linq/forms` | `@jarenjs/forms` | [forms pen](#by-code-the-forms-pen) · [FORMS-PEN](docs/FORMS-PEN.md) |
+| an AI action program | `@jarenjs/linq/ai` | `@jarenjs/ai` | [AI-PEN](docs/AI-PEN.md) |
+| a message catalog | `@jarenjs/linq/messages` | `@jarenjs/core/message` | [MESSAGES-PEN](docs/MESSAGES-PEN.md) |
+| a text template | `@jarenjs/linq/jtlt` | `@jarenjs/json/jtlt` | [JTLT-PEN](docs/JTLT-PEN.md) |
+| a Studio project | `@jarenjs/linq/project` | `@jarenjs/studio` | [PROJECT-PEN](docs/PROJECT-PEN.md) |
+| a chart | `@jarenjs/linq/charts` | `@jarenjs/charts` | [CHARTS-PEN](docs/CHARTS-PEN.md) |
 | typed handles on the store | `@jarenjs/linq/db` | the front door, not a pen | [the front door](#the-front-door-jarenjslinqdb) · [DB-CLIENT](docs/DB-CLIENT.md) |
 
 The rules every pen keeps — what a pen may spell, what it must refuse,
@@ -716,4 +724,9 @@ Every subpath a consumer can import, derived from the manifest by
 | `@jarenjs/linq/forms` | JavaScript | declared |
 | `@jarenjs/linq/db` | JavaScript | declared |
 | `@jarenjs/linq/package.json` | metadata | — |
+| `@jarenjs/linq/charts` | JavaScript | declared |
+| `@jarenjs/linq/project` | JavaScript | declared |
+| `@jarenjs/linq/jtlt` | JavaScript | declared |
+| `@jarenjs/linq/messages` | JavaScript | declared |
+| `@jarenjs/linq/ai` | JavaScript | declared |
 <!--/fact-->

package/docs/AI-PEN.md

@@ -0,0 +1,98 @@
+# The AI program pen
+
+> `./ai` — the public action program over environment slots. **Read it when**
+> you want typed fixtures or host-authored programs without a model client.
+
+## 1. What it writes
+
+The pen emits exactly `{ steps: [...] }`, the document consumed by the AI
+program schema, compiler and runner. It imports no AI engine or environment.
+`.schema` is an independent, deeply frozen JSON snapshot; `JSON.stringify()`
+writes that document. Updates return a new builder.
+
+`program(['corpus'])` declares input names for TypeScript; those names never
+become extra document members or an embedded registry. The compiler checks the
+real environment. Queries can be raw JSON or callbacks recorded over the input
+document, using the same capture as other pens and no runtime query engine.
+
+## 2. The mapping table
+
+Factories return frozen public steps. The same method on a program appends that
+step. Every non-answer step writes `op`, `from` and `as` before its options.
+
+| Factory / method | Emits | Type | Status |
+|---|---|---|---|
+| `program(slots?)` | empty `steps` | declared input names | native |
+| `chunk(from, as, options?)`, `.chunk(...)` | chunk; strategy and size | result family | native |
+| `grep(from, as, options)`, `.grep(...)` | grep; pattern, flags, limit | match-list slot | native |
+| `select(from, as, query)`, `.select(...)` | select; query JSON | result slot | native |
+| `stat(from, as)`, `.stat(...)` | stat | result slot | native |
+| `peek(from, as)`, `.peek(...)` | peek | result slot | native |
+| `map(from, as, prompt)`, `.map(...)` | map; bounded instruction | result family | native |
+| `reduce(from, as, query, options?)`, `.reduce(...)` | reduce; query JSON and optional `outputSchema` | result slot | native |
+| `answer(from, options?)`, `.answer(...)` | answer; optional chars, no as | terminal program | native |
+| `.step(step)` | appends a public step | tracks its input/result names | native |
+| `from(document)` | raw program | no binding-order inference | native |
+| `.schema`, `.toJSON()` | frozen public JSON | program document | native |
+
+`chunk` options are `strategy: 'size' | 'line' | 'separator'` and `size`.
+`grep` requires `pattern`, with optional `flags: 'i' | 'm' | 'im' | ''` and
+`limit`. `answer` takes `chars`. The schema owns numeric and string bounds.
+
+## 3. Worked examples
+
+```js
+import { program } from '@jarenjs/linq/ai';
+export const plan = program(['corpus'])
+  .chunk('corpus', 'pieces', { strategy: 'line', size: 200 })
+  .map('pieces', 'found', 'Return the number in this piece as JSON')
+  .reduce('found', 'count', { $count: '$[*]' })
+  .answer('count', { chars: 50 });
+```
+```json
+{"steps":[{"op":"chunk","from":"corpus","as":"pieces","strategy":"line","size":200},{"op":"map","from":"pieces","as":"found","prompt":"Return the number in this piece as JSON"},{"op":"reduce","from":"found","as":"count","query":{"$count":"$[*]"}},{"op":"answer","from":"count","chars":50}]}
+```
+
+Validate with `PROGRAM_SCHEMA` (or `programSchema({ queryRef })`), then
+`compileProgram`/`programGate` with the query compiler and known environment
+names. `createProgramRunner` does both shape and compile checks before execution.
+The standalone compile gate checks semantics; it does not replace the shape
+schema's numeric ranges, member closure or step-count cap.
+
+## 4. Refusals
+
+| Code | Condition |
+|---|---|
+| `JL0101` | invalid slot/result name shape, unknown option/operation, non-JSON input, or a malformed input-name list |
+| `JL0102` | appending a step after answer |
+| `JL0104` | a query callback reads an external; program queries bind only their input document |
+
+The schema/compiler own unknown environment names, duplicate result bindings,
+missing answers, limits, query validity and family/slot semantics. `from()`
+preserves raw programs for those checks rather than carrying a second compiler.
+
+## 5. The types
+
+`ProgramBuilder<Bindings, Done>` tracks names and whether answer has closed the
+program. `ProgramDocument`, `Step`, `StepDocument`, `StepOptions`, `Operation`,
+`Query`, `ChunkOptions`, `GrepOptions` and `AnswerOptions` are types only.
+
+A later step may read only a declared input or previous result. `select` and
+`answer` read individual slots, not chunk/map families; `reduce` reads map
+results. A result cannot be rebound, although an input slot can be shadowed as
+in the compiler. Standalone step factories retain literal names and `.step()`
+checks them on insertion. Raw documents claim neither binding order nor a
+terminal state. No inferred data schema, budget or successful-run guarantee is
+attached to a program.
+
+## 6. What it cannot spell
+
+This is the action document, not a prompt/client wrapper. It neither pastes
+corpus contents into a private envelope nor runs model calls in query expressions.
+Only the existing runner's map step calls a model. Cancellation, concurrency,
+sub-call budgets, storage and result interpretation remain runner concerns.
+
+## 7. Cost
+
+The isolated AI program pen costs **<!--fact:bundle.ai-->16,904<!--/fact--> bytes**.
+Its tree probe excludes AI, other target engines and the query chain.

package/docs/APP-PEN.md

@@ -1123,7 +1123,7 @@ not look for them:
 
 ## 7. Cost
 
-`@jarenjs/linq/app` builds to **<!--fact:bundle.app-->47,444<!--/fact--> bytes** as a minified,
+`@jarenjs/linq/app` builds to **<!--fact:bundle.app-->51,006<!--/fact--> bytes** as a minified,
 tree-shaken ESM bundle — the figure `scripts/check-tree-shaking.js`
 measures and `npm run test:tree-shaking` reports, published rounded
 beside the other nine subpath prices in
@@ -1133,8 +1133,8 @@ pen and the JSLT pen (state, and views), and no chain module, no
 
 It is the second-largest pen bundle after the client, and the two pens
 it carries are most of it. The three figures the same probe measures,
-side by side: `@jarenjs/linq/schema` <!--fact:bundle.schema-->33,156<!--/fact--> bytes,
-`@jarenjs/linq/jslt` <!--fact:bundle.jslt-->19,856<!--/fact-->, `@jarenjs/linq/app` <!--fact:bundle.app-->47,444<!--/fact-->. The subpath sums do not add — all
+side by side: `@jarenjs/linq/schema` <!--fact:bundle.schema-->36,717<!--/fact--> bytes,
+`@jarenjs/linq/jslt` <!--fact:bundle.jslt-->19,856<!--/fact-->, `@jarenjs/linq/app` <!--fact:bundle.app-->51,006<!--/fact-->. The subpath sums do not add — all
 three carry the capture, the expression lowering and the JSON boundary,
 which each bundle counts once — so what the app pen costs a consumer who
 already imports the schema pen is the difference the numbers do state:

package/docs/CHARTS-PEN.md

@@ -0,0 +1,94 @@
+# The chart pen
+
+> `./charts` — chart-definition documents for every chart kind. **Read it when**
+> you want typed chart data and presentation options that `compileChart` consumes.
+
+## 1. What it writes
+
+Import the kind you need from `@jarenjs/linq/charts`. Each factory starts a
+public chart definition with its literal `type`. Fluent methods replace one
+member; `options()` replaces several. `.schema` is an independent, deeply
+frozen JSON document, and `JSON.stringify(builder)` serializes that document.
+
+The pen imports no chart renderer. Its declarations and known member vocabulary
+are derived from the public chart grammar with `@jarenjs/emit`. Run
+`node scripts/generate-chart-pen.js` after a grammar change; the drift gate
+compares both generated files with that grammar.
+
+## 2. The mapping table
+
+The factory determines the available methods and their argument types. Every
+method below preserves that discriminator and replaces a previous value.
+Nested series and axis fragments use the shapes shared by the public grammar.
+
+| Method | Emits | Type | Status |
+|---|---|---|---|
+| `pie(options?)`, `bar(options?)`, `line(options?)`, `scatter(options?)` | the named `type` and options | corresponding chart | native |
+| `candlestick(options?)`, `radar(options?)`, `gauge(options?)`, `boxplot(options?)` | the named `type` and options | corresponding chart | native |
+| `heatmap(options?)`, `treemap(options?)`, `streamgraph(options?)`, `sankey(options?)`, `map(options?)` | the named `type` and options | corresponding chart | native |
+| `.options(object)` | supplied known members | same kind | native |
+| `.title(text)`, `.stream(spec)` | `title`, `stream` | same kind | native |
+| `.donut(value)`, `.slices(values)` | pie members | pie | native |
+| `.stacked(value)`, `.orient(value)`, `.categories(values)` | bar members | bar | native |
+| `.log(value)`, `.catLabel(text)`, `.valLabel(text)` | members on kinds that declare them | same kind | native |
+| `.series(values)` | the kind's series shape | same kind | native |
+| `.x(value)`, `.markers(value)`, `.sampling(value)` | line members | line | native |
+| `.xLabel(text)`, `.yLabel(text)`, `.domain(spec)`, `.dateNames(names)`, `.timeFormats(formats)` | axis members on their declared kinds | same kind | native |
+| `.xLog(value)`, `.yLog(value)`, `.refY(value)`, `.refLabel(text)` | scatter members | scatter | native |
+| `.points(values)`, `.candles(values)` | the kind's point/candle data | same kind | native |
+| `.axes(values)`, `.max(value)`, `.min(value)` | radar/gauge members | same kind | native |
+| `.value(value)`, `.unit(text)`, `.tone(value)` | gauge values; map `value` is a property name | same kind | native |
+| `.boxes(values)`, `.xLabels(values)`, `.yLabels(values)`, `.values(values)` | boxplot/heatmap members | same kind | native |
+| `.aspect(value)`, `.items(values)`, `.xs(values)` | treemap/map/streamgraph members | same kind | native |
+| `.nodes(values)`, `.links(values)` | sankey members | sankey | native |
+| `.label(text)`, `.simplify(value)`, `.features(values)` | map members | map | native |
+| `from(document)` | raw document, including extensions | declared chart shape | native |
+| `.schema`, `.toJSON()` | frozen public document | chart definition | native |
+
+## 3. Worked examples
+
+```js
+import { bar } from '@jarenjs/linq/charts';
+export const chart = bar().categories(['A', 'B'])
+  .series([{ name: 'Sales', values: [3, 5] }]).title('Sales');
+```
+```json
+{"type":"bar","categories":["A","B"],"series":[{"name":"Sales","values":[3,5]}],"title":"Sales"}
+```
+
+Pass `chart.schema` to `compileChart` from `@jarenjs/charts`, then call
+`toVnode()` or `toSvgString()` on the compiled result. Streaming consumers may
+omit data members and supply data through the chart engine's separate argument.
+
+## 4. Refusals
+
+| Code | Condition |
+|---|---|
+| `JL0101` | a non-JSON value, non-plain option map, unknown kind or option, or a fluent member on a kind that does not declare it |
+
+Numeric ranges and relationships among data members remain the chart grammar's
+and renderer's responsibility. For extension fields use `from(document)`.
+
+## 5. The types
+
+`ChartBuilder` is the exported runtime class. `ChartPen<K>` adds precisely the
+methods permitted by kind `K`; `ChartKind`, `ChartDefinitions`, `ChartOptions`
+and the individual chart/fragment interfaces are types only. A bar series takes
+`values`; a line series takes `points`. A gauge's `value` is numeric, while a
+map's `value` names a feature property. `.options()` preserves the kind too.
+
+The runtime tests enumerate every schema kind and top-level member, validate
+each emitted document and compare its AST and SVG with the hand-written input.
+The consumer type pins reject cross-kind methods and malformed series values.
+
+## 6. What it cannot spell
+
+Functions, engine instances and callbacks are not JSON chart definitions.
+The pen does not compile geometry, validate longitude ranges, supply themes or
+render tooltips; those responsibilities remain in the chart engine.
+
+## 7. Cost
+
+The isolated chart pen costs **<!--fact:bundle.charts-->17,014<!--/fact--> bytes**.
+The tree-shaking gate refuses chart engine, other target engine and chain
+modules in this bundle, and checks that the chain and schema pen do not import it.

package/docs/CONTRACT-PEN.md

@@ -1188,10 +1188,10 @@ to write, and reaching them means one import of `@jarenjs/contract` over
 
 ## 7. Cost
 
-`@jarenjs/linq/contract` builds to **<!--fact:bundle.contract-->45,298<!--/fact--> bytes** as a minified,
+`@jarenjs/linq/contract` builds to **<!--fact:bundle.contract-->48,859<!--/fact--> bytes** as a minified,
 tree-shaken ESM bundle — the figure `scripts/check-tree-shaking.js`
 measures and `npm run test:tree-shaking` reports, published rounded
-(<!--fact:bundle.contract.kb-->45<!--/fact--> kB) beside the other nine subpath prices in
+(<!--fact:bundle.contract.kb-->49<!--/fact--> kB) beside the other nine subpath prices in
 [docs/CONSUMING.md](../../../docs/CONSUMING.md).
 
 The probe is a gate, not a report: building a one-operation contract as a
@@ -1200,7 +1200,7 @@ them:
 
 - **the schema pen is included, and that is the ceiling.** A contract's
   inputs and outputs are schemas, so the two are measured together and
-  the bundle carries <!--fact:bundle.schema-->33,156<!--/fact--> of its <!--fact:bundle.contract-->45,298<!--/fact--> bytes as the schema pen's own.
+  the bundle carries <!--fact:bundle.schema-->36,717<!--/fact--> of its <!--fact:bundle.contract-->48,859<!--/fact--> bytes as the schema pen's own.
   The contract pen's own share is the remaining ~12 kB, most of it the
   refusal messages §4 lists;
 - **no chain module** — none of `sequence.js`, `document.js`, `async.js`,
@@ -1216,6 +1216,6 @@ them:
 A consumer who writes a contract and also compiles it pays both prices
 and they add rather than overlap. That is the shape the separation is
 for: a browser bundle that only needs the TYPES a contract implies —
-`typedClient` over an HTTP binding, say — ships the pen's <!--fact:bundle.contract.kb-->45<!--/fact--> kB and none
+`typedClient` over an HTTP binding, say — ships the pen's <!--fact:bundle.contract.kb-->49<!--/fact--> kB and none
 of the compiler, while the server that serves the contract imports
 `@jarenjs/contract` and does not need the pen at all.

package/docs/DB-CLIENT.md

@@ -826,10 +826,10 @@ never builds one; the migration between two of them is
 
 ## 7. Cost
 
-`@jarenjs/linq/db` builds to **<!--fact:bundle.db-->623,994<!--/fact--> bytes** as a minified,
+`@jarenjs/linq/db` builds to **<!--fact:bundle.db-->625,827<!--/fact--> bytes** as a minified,
 tree-shaken ESM bundle — the figure `scripts/check-tree-shaking.js`
 measures and `npm run test:tree-shaking` reports, published rounded
-(<!--fact:bundle.db.kb-->624<!--/fact--> kB) beside the other nine subpath prices in
+(<!--fact:bundle.db.kb-->626<!--/fact--> kB) beside the other nine subpath prices in
 [docs/CONSUMING.md](../../../docs/CONSUMING.md).
 
 It is by far the largest of the ten, and the reason is §1.1's edge rather
@@ -856,7 +856,7 @@ What the probe asserts, and fails the build on:
   asserts the same exclusion.
 
 A consumer who wants the model pen's types without the store pays
-`./model`'s <!--fact:bundle.model-->41,582<!--/fact--> bytes and installs no peer; one who wants to run
+`./model`'s <!--fact:bundle.model-->45,143<!--/fact--> bytes and installs no peer; one who wants to run
 queries against an array rather than a database pays the chain's price
 (§17 of [QUERY-PEN.md](QUERY-PEN.md)) and installs no peer. `./db` is
 the one subpath whose `package.json` entry carries an optional peer at

package/docs/FORMS-PEN.md

@@ -925,7 +925,7 @@ for this pen at all.
 
 ## 7. Cost
 
-`@jarenjs/linq/forms` builds to **<!--fact:bundle.forms-->37,312<!--/fact--> bytes** as a minified,
+`@jarenjs/linq/forms` builds to **<!--fact:bundle.forms-->40,873<!--/fact--> bytes** as a minified,
 tree-shaken ESM bundle — the figure `scripts/check-tree-shaking.js`
 measures and `npm run test:tree-shaking` reports, published rounded
 beside the other nine subpath prices in
@@ -934,7 +934,7 @@ pen it subclasses, and no chain module, no `@jarenjs/forms` byte and no
 model pen.
 
 Most of that figure is the schema pen: `@jarenjs/linq/schema` alone
-is <!--fact:bundle.schema-->33,156<!--/fact--> bytes, so the whole `x-form` vocabulary — the mixin, the rule
+is <!--fact:bundle.schema-->36,717<!--/fact--> bytes, so the whole `x-form` vocabulary — the mixin, the rule
 capture, the submit transform and their refusal messages — is about 4 kB
 on top of a pen a form-shaped consumer usually already carries. A
 consumer importing both subpaths pays the schema pen once.

package/docs/JTLT-PEN.md

@@ -0,0 +1,83 @@
+# The JTLT pen
+
+> `./jtlt` — text templates with JSLT dispatch and query expressions. **Read it
+> when** you want to author Markdown, XML or source text as portable JSON.
+
+## 1. What it writes
+
+The pen emits the public JTLT 0.1 envelope or its bare rule-array shorthand.
+`.schema` is a deeply frozen JSON snapshot; serializing a builder writes exactly
+that document. The published latest and draft-07 grammars came first and are
+held to the existing renderer's complete fixture corpus.
+
+The pen captures expressions but imports no query engine or JTLT renderer.
+Pass its document to `compileJtltStylesheet` or `validateJtltTemplate` from
+`@jarenjs/json/jtlt`. The [format](../../json/docs/JTLT-FORMAT.md) defines
+escaping, dispatch, matching, output and the structural/compiler boundary.
+
+## 2. The mapping table
+
+| Method | Emits | Type | Status |
+|---|---|---|---|
+| `text(string)` | literal text; doubles a leading `$` | string segment | native |
+| `query(expression, options?)` | raw or captured query string/object | interpolated segment | native |
+| `raw(expression, options?)` | `{ $raw: expression }` | unescaped interpolation | native |
+| `json(expression, options?)` | `{ $json: expression }` | JSON serialization | native |
+| `apply(selector, mode?, options?)` | `$apply` selector or selector/mode list | dispatch splice | native |
+| `rule(body?, options?)` | body and optional match/mode/priority | rule | native |
+| `.body(segments)`, `.match(spec)`, `.mode(string)`, `.priority(number)` | replacement rule member | same rule | native |
+| `stylesheet(rules?, options?)` | `$jtlt`, optional output, rules | envelope | native |
+| `bare(rules?)` | public rule array | shorthand | native |
+| `.rules(rules)`, `.rule(rule)` | replace or append rules | preserves envelope/shorthand | native |
+| `.output(method)` | output method; wraps a bare list in an envelope | text or XML | native |
+| `from(document)` | raw template with member order preserved | template | native |
+| `.schema`, `.toJSON()` | frozen public JSON | document | native |
+
+Expression callbacks receive the matched value and declared externals. Supply
+`{ externals: ['rate'] }` as options to name a user parameter; `root` and `path`
+are already bound by JTLT. Captured `.get()` paths use bracket notation, as in
+other pens. Raw query documents retain the author's spelling. Nested arrays
+remain nested segment lists, and literal containers belong inside `json()`.
+
+## 3. Worked examples
+
+```js
+import { stylesheet, rule, apply, text } from '@jarenjs/linq/jtlt';
+export const template = stylesheet([
+  rule([text('# Books\n'), apply('$.books[*]')], { match: '$' }),
+  rule(['- ', '$.title', '\n'], { match: '$.books[*]' }),
+]);
+```
+```json
+{"$jtlt":"0.1","rules":[{"match":"$","body":["# Books\n",{"$apply":"$.books[*]"}]},{"match":"$.books[*]","body":["- ","$.title","\n"]}]}
+```
+
+## 4. Refusals
+
+| Code | Condition |
+|---|---|
+| `JL0101` | non-JSON input, unknown option, invalid list/text/output/mode argument, invalid or repeated external declaration, or a query segment that is neither a string nor query object |
+| `JL0104` | a capture callback reads an undeclared external |
+
+The shared capture also enforces the binder's expression rules. The JTLT compiler
+checks match syntax, query arguments, hooks and the reserved priority band;
+rendering checks input-dependent serialization and recursion. No type claims
+that a template will render every possible input.
+
+## 5. The types
+
+`RuleBuilder` and `TemplateBuilder` are runtime classes. `RuleDocument`,
+`TemplateDocument`, `Segment`, `Match`, `Output`, `QueryInput` and `QueryOptions`
+are types. The output is text; no inferred schema for rendered content is claimed.
+The external-name phantom catches misspellings without adding a runtime registry.
+
+## 6. What it cannot spell
+
+Functions and engine objects cannot enter documents. Callbacks are recorded into
+query JSON before emission. The pen does not escape an entire finished document,
+validate XML well-formedness, render text, or add a second dispatch language.
+
+## 7. Cost
+
+The isolated JTLT pen costs **<!--fact:bundle.jtlt-->16,725<!--/fact--> bytes**.
+Its tree probe excludes target engines and the query chain.