quario 0.12.0 → 0.14.0

package/CHANGELOG.md

@@ -1,5 +1,165 @@
 # quario
 
+## 0.14.0
+
+### Minor Changes
+
+- **`quario(options)` now refuses an option it does not understand, like every target factory.** Before, the engine read the keys it knew and ignored the rest. A typo such as `quario({ licence })` therefore marked every render as unlicensed, and nothing said why. Now an unknown key, a value of the wrong type, or an `options` that is not an object throws a `TypeError` at the call. The message names the option path, such as `options.license`.
+
+  **`locale`, `timeZone` and `currency` are now checked at the call.** Before, a value that `Intl` refused did not fail. Every formatted cell showed its raw value instead. Now `quario({ locale: "en_US" })` and `quario({ timeZone: "Europe/Amsterdm" })` throw a `TypeError`. `currency` must be three upper-case letters, the same rule that a cell's own `currency` declaration follows. A cell's own `currency` still fails soft.
+
+  **The `query` budgets are now checked at the call.** Before, the engine checked them only when a report compiled its first query. A report with no query never reported a bad budget. The error still comes from padvinder, in its own words.
+
+  **`plan(schema, functions, options)` now refuses an unknown key in `options`.** Before, `{ target: [...] }` checked nothing and said nothing. A `targets` that is not an array also throws a `TypeError`.
+
+  **A bad `schemes` allowlist now throws a `TypeError`, not an `Error`.** The message starts with `options.schemes:`, not `schemes:`. A `null` allowlist still throws.
+
+  **What this changes for you.** An options object that carries keys for another consumer stops working when you pass it to `quario()`. Pass `quario()` only the six keys it takes: `query`, `license`, `locale`, `currency`, `timeZone` and `schemes`.
+
+- **A group can now order and cut its instances.** Declare `instances` beside `sort`, with an optional `sort` and an optional `take` inside it. They order and cut the group's instances, as the group's own `sort` and `take` order and cut the rows inside each instance. Each `instances.sort` key reads the group's own handle once per instance, so `instances: { sort: [{ by: "=region.subtotal", dir: "desc" }], take: 5 }` keeps the five regions with the largest subtotals, largest first. `@` and `run` are unbound there. A dropped instance never renders, and no running value steps over it. The totals around the group still count it, as they count a row that a group's `take` drops. A group without `instances` renders every instance in first-seen order, so existing reports render as before.
+- **An image item now accepts SVG bytes.** Before, `source` had to yield PNG or JPEG bytes, and SVG bytes were a render error. Now the engine also names UTF-8 text whose root element is `<svg` as an SVG, and the image event carries `format: "svg"`. The engine reads the size from the root's `width` and `height` when both are absolute lengths, and else from its `viewBox`. An SVG that states no size this way is the same render error as a PNG that is too short to state its size. The message for bytes that are not an image now says "PNG, JPEG or SVG".
+
+  The HTML target puts an SVG in an `<img>` under `data:image/svg+xml`, so the SVG never becomes markup in the fragment. The PDF target draws an SVG as vector paths. It draws no picture that the SVG names, and it fetches nothing. SVG `<text>` draws in the standard Helvetica. The viewer paints an SVG through a `data:` URI, so a page that shows one needs the Content Security Policy grant `img-src data:`. A PNG or a JPEG still needs no grant there. The XLSX and DOCX targets cannot draw an SVG, so an SVG image is a render error that names the item.
+
+### Patch Changes
+
+- **The package now carries edition 1.1 of the Quario License Agreement.** A license now covers one production deployment, not one developer. Each deployment needs one license key. Development, staging, CI and test environments need no key. A key covers every release dated up to one year after you buy it, and those releases stay licensed for good. A key is not a subscription, and it never renews automatically. A refunded or reversed payment voids the keys it bought. Software that your customers install or resell needs separate OEM terms.
+
+## 0.13.0
+
+### Minor Changes
+
+- A band gains a `grid` item: splits that share one column geometry.
+
+  A statement is twenty lines of a label and an amount, on the same two widths. As splits, each line restated its widths:
+
+  ```jsonc
+  { "type": "split", "slots": [
+    { "type": "text", "value": "Opening", "width": 70 },
+    { "type": "text", "value": "{{ @.opening }}", "width": 30, "style": { "align": "right" } }
+  ] }
+  ```
+
+  A grid states the widths, and each column's style, once:
+
+  ```jsonc
+  {
+    "type": "grid",
+    "columns": [{ "width": 70 }, { "width": 30, "style": { "align": "right" } }],
+    "rows": [
+      { "slots": [{ "type": "text", "value": "Opening" }, { "type": "text", "value": "{{ @.opening }}" }] },
+      {},
+      { "slots": [{ "type": "text", "value": "Total" }, { "type": "text", "value": "{{ @.total }}" }], "style": { "bold": true } }
+    ]
+  }
+  ```
+
+  A row is a split without `type`, and it keeps every rule a split has. A column's `style` is the layer under each of its slots, and a slot's own declarations win. A row that names fewer slots than there are columns leaves the rest empty, so `{}` is a spacer line and a one-slot row is a label-only line.
+
+  Each row reaches a target as the split it is, so the event stream does not change and no target needed an update. No existing report changes.
+
+- The package now ships a JSON Schema of the report document.
+
+  The file is `lib/schema.json`, and the package exports it as `quario/schema.json`. Point `$schema` at the installed copy, and an editor checks the document and shows the documentation for each key:
+
+  ```jsonc
+  { "$schema": "./node_modules/quario/lib/schema.json", "data": "$.orders[*]" }
+  ```
+
+  A report document accepts one new top-level key, `$schema`. Its value must be a string. The engine checks the type and reads nothing else, so a document keeps its `$schema` through an upgrade. Anywhere below the top level, `$schema` stays an unknown key.
+
+  The JSON Schema proves the shape of each value, and `validate()` still proves the document. A document can pass the JSON Schema and fail `validate()`: a rule across two values, a reserved name, or an expression that does not compile. The strict structured-output modes of OpenAI and Anthropic do not accept the file, because a report document leaves most of its keys out.
+
+  The TypeScript declarations are stricter in one place. A parameter's value under `params` is now typed as any JSON value except a plain object. The engine always read a plain object there as a declaration, so a document that the new type refuses was never the document it looked like.
+
+- **A license key has an end date and no start date.** A key covers every version released on or before its `to` date. Before, a key also named a `from` date, and a version released before that date stayed marked. The engine now ignores a `from` in a key. When a key ends before the release date of the installed version, the warning names both dates.
+- A value the runtime has no text form for is now a located render error rather than `[object Object]` in the document.
+
+  A cell reaches its reader through `String(value)`. A plain object, a `Map` and a `Set` have no text form of their own, so that falls back to a tag: `[object Object]`, `[object Map]`, `[object Set]`. A tag lays out, paginates and lands in a worksheet cell, and the document is wrong. A few values have no text form at all, and `String()` throws on them — an object with no prototype, a boxed symbol. The engine now refuses both kinds and names the cell:
+
+  ```
+  detail[0].value [{{ @.address }}]: a value with no text form, which would print as [object Object]
+  ```
+
+  The rule reads the value, not its source, so a registered function's result and a data field answer to it alike. A value that says what it is still prints it: a class with its own `toString`, an array (`[1, 2]` prints `1,2`), a `Date`. An absent read still prints nothing. A computed property is outside the rule, because a group's `by` is an identity rather than text — `by: "=@"` makes each row its own instance — and a `where` and a `visible` are read for truth.
+
+  Every entry in the function registry must be a function. `plan` reports one that is not at `functions.<name>`, where before it raised an unhandled `TypeError` out of `plan` itself at a caller who had only asked a question.
+
+  A report that printed `[object Object]` stops rendering. It was printing a value no reader could use.
+
+- A document may now name its paper and turn it, and its margin may name each side.
+
+  ```jsonc
+  {
+    "page": {
+      "size": "letter",
+      "orientation": "landscape",
+      "margin": { "top": 36, "right": 29, "bottom": 36, "left": 29 }
+    }
+  }
+  ```
+
+  `page.size` takes `"A4"` or `"letter"`. A `[width, height]` pair stays a target option. `page.orientation` takes `"portrait"` or `"landscape"`, and it turns whichever paper is in force. `page.margin` still takes one number for all four sides.
+
+  The rule `page.margin` already followed now covers all three keys. The document's key wins where it declares one, a target option applies where it does not, and both declaring the same key is a render error. `orientation` in a document beside a target's `size` is not both.
+
+  Each target writes the paper: the PDF and the layout draw on it, HTML writes an `@page` size and per-side margin, and DOCX writes `pgSz` with `w:orient` and `pgMar` per side. XLSX writes the paper code, the orientation and each print margin. CSV withdraws all three.
+
+  The capability descriptors gain `page.size` and `page.orientation`, and both are names a document may mark `required`.
+
+  A target's margin error now reads `expected a non-negative number, or { top, right, bottom, left }, that leaves the page room`.
+
+- `params` is now what the report declares it needs, and a render may supply one.
+
+  A bare value under `params` still **is** the parameter's value, so a document of constants reads the way it always did:
+
+  ```jsonc
+  { "params": { "year": 2025, "branded": true } }
+  ```
+
+  A plain object is a **declaration** instead, closed at `default` and `type`:
+
+  ```jsonc
+  {
+    "params": {
+      "year": { "type": "number", "default": 2025 },
+      "region": { "type": "string" }
+    }
+  }
+  ```
+
+  `type` names a JSON kind — `string`, `number`, `boolean`, `array`, `object` — because a parameter is a JSON value. There is no `date` and no `enum`.
+
+  **`default` absent makes the parameter required.** The engine rejects a render that supplies no value for it, before any expression runs. That is the main thing declaring buys: a report that states what it needs hears about it when a render does not bring it.
+
+  A host supplies values as the last argument to `render` and to `stream`:
+
+  ```js
+  await report.render(html(), data, { region: "EU" });
+  ```
+
+  Only a declared key may be supplied, a supplied value answers to the declared `type`, and values stay JSON and deep-frozen — now per render rather than once at compile.
+
+  **One kind of document changes meaning.** The engine reads an object-valued parameter as a declaration, so a document that wrote one for its value wraps it:
+
+  ```jsonc
+  { "params": { "config": { "default": { "retries": 3 } } } }
+  ```
+
+  An empty object is the sharpest case. `{ "config": {} }` now declares a parameter with no default, so every render of that document is refused until one supplies a value, or until the document wraps it.
+
+  Nothing else moves. A bare string, number, boolean or array is untouched.
+
+  A declaration may also carry a `label`, the text a person reads for the parameter. A labelled parameter is one a person supplies, so a host panel shows only those. The engine never renders a label.
+
+  A `null` default beside a `type` makes a typed parameter optional, and a render may then supply `null`:
+
+  ```jsonc
+  { "params": { "branch": { "type": "string", "default": null, "label": "Branch" } } }
+  ```
+
+  A host reads what a document declares from `report.params` and from `plan(...).params`: one frozen `{ name, required, type?, default?, label? }` per parameter, in declaration order. A plan carries them whether or not the document compiled, so an editor can render a panel beside the problems.
+
 ## 0.12.0
 
 ### Minor Changes

package/LICENSE

@@ -1,179 +1,200 @@
 # Quario License Agreement
 
 > **In short:** Quario is commercial software with visible source.
-> Evaluate it free for as long as you like. Evaluation output is
-> watermarked. Anything else needs a per-developer license, after
-> which deployment is unlimited and royalty-free. This summary is not
-> the license; the full terms below govern.
+> You may evaluate it and develop with it free, for as long as you
+> like. The Software marks output that no license key covers. Each
+> production deployment needs one license key. A key covers one year
+> of releases, and those releases stay licensed for good. This summary
+> is not the license. The full terms below govern.
 
-Version 1.0, August 2026
+Version 1.1, October 2026
 
 This agreement is between you and Webstronauts, trading as Quario,
-established in the Netherlands ("we", "us"), and governs the Software
+established in the Netherlands ("we", "us"). It governs the Software
 defined below.
 
 Quario is commercial software. Its packages ship with readable source
-code, but it is not open source. No rights are granted beyond those in
-this agreement.
+code, but it is not open source. This agreement grants no rights
+beyond those it states.
 
 ## 1. Definitions
 
 - The **Software** is any software we publish under the Quario name,
   including the `quario` and `@quario/*` packages, except where a
   product states its own terms. Each release states the edition of this
-  agreement that governs it.
-- **You** means the individual exercising rights under this agreement
-  and, where that individual acts for a company or other organization,
-  that organization. In that case the organization is the licensee, and
-  the rights and limits in this agreement apply to it as a whole.
+  agreement that governs it. A license key bought under this edition
+  licenses every release it covers under this edition, including
+  releases that shipped with an earlier edition.
+- **You** means the individual who exercises rights under this
+  agreement. Where that individual acts for a company or other
+  organization, **you** also means that organization. In that case the
+  organization is the licensee, and the rights and limits in this
+  agreement apply to it as a whole.
 - An **Application** is software you create that incorporates the
-  Software and adds substantial functionality beyond it. A
-  licensee-operated service that embeds the Software and renders
-  reports for your End Users is an Application under this agreement,
-  even if it does little more than render.
-- A **Developer** is any individual (employee or contractor working on
-  your behalf) who writes or maintains code that uses the Software's
-  APIs, or who creates or maintains report definitions for use with the
-  Software. That includes people who never install or run the Software
-  themselves, when their definitions are rendered by a service that
-  embeds it.
-- A **Seat** is a paid license for one named Developer, purchased from
-  us or an authorized reseller.
+  Software and adds substantial functionality beyond it. A service you
+  operate that embeds the Software and renders reports for your End
+  Users is an Application, even if it does little more than render.
+- A **Deployment** is one production service, application, bot, worker
+  or MCP server that runs the Software under your control. All replicas
+  of it together are one Deployment. A service that only passes render
+  requests to another service does not run the Software, so it is not
+  a Deployment. A service that a host or contractor operates on your
+  behalf stays under your control. Development, staging, CI and test
+  environments are not Deployments. We never count the people, agents
+  or renders that a Deployment serves.
+- A **License Key** is the signed key that evidences the license of
+  one Deployment. You buy it from us or from an authorized reseller.
 - **End Users** are people who interact with the Software only through
-  an Application: running it, viewing the reports it produces, or
-  supplying parameters or other input to existing report definitions
-  the Application provides. Creating or maintaining report definitions
-  makes someone a Developer. End Users do not purchase a license; their
-  rights come from section 5.
+  an Application that runs in a Deployment. They run it, view the
+  reports it produces, or supply parameters, input or report
+  definitions to it. End Users do not buy a license. Their rights come
+  from section 5.
 
 ## 2. Acceptance
 
-This file is our standing offer. Anyone who exercises the evaluation
-rights in section 3 accepts them, subject to their conditions. All
-other rights arise when Seats are purchased. Where a purchase is made
-for an organization, the person completing it confirms that they are
-authorized to accept this agreement on the organization's behalf, and
-acceptance covers the whole organization. If you do not accept this
+This file is our standing offer. Anyone who exercises the rights in
+section 3 accepts them, subject to their conditions. All other rights
+start when you buy a License Key. Where a person buys for an
+organization, that person states that they have the authority to
+accept this agreement on the organization's behalf. The acceptance
+then covers the whole organization. If you do not accept this
 agreement, do not use the Software.
 
-## 3. Evaluation
-
-You may download, install, and use the Software free of charge to
-evaluate it: assessing whether it suits your purposes, and building
-prototypes or proofs of concept. Evaluation covers the full feature
-set, needs no key, and has no fixed time limit. The Software marks
-evaluation output as described in section 6.
-
-Evaluation is limited to assessment: you may not distribute any
-Application containing the Software, use the Software in live business
-operations, or expose it in services offered to third parties. The
-moment your use goes beyond evaluating the Software, it requires Seats
-under section 4.
-
-## 4. Developer licenses
-
-Any use of the Software beyond section 3 requires a Seat for every
-Developer, whether or not an Application has shipped. With those Seats
-in place:
-
-- Each licensed Developer may install and use the Software on any number
-  of machines for developing Applications.
-- Automated build, test, and CI systems do not consume Seats.
-- Seats are per named individual. They may be reassigned when a
-  Developer stops working with the Software, but not shared or pooled
-  between concurrently active Developers. Contractors' work for you is
-  covered by your Seats; work they do for other clients is not.
-
-## 5. Distribution and runtime
-
-With Seats under section 4 in place, you may deploy and operate your
-Applications yourself, and distribute the Software as an embedded part
-of them, **royalty-free**: no additional fees or per-deployment
-licenses are required for any number of servers, copies, or End Users.
-You may embed your license key in an Application and ship it at no
-charge, so section 6 does not mark that Application's output.
-
-For that purpose, we grant you the right to pass through to each End
-User, and to anyone who distributes or operates your Application on your
-behalf, a limited, non-exclusive, non-transferable right to execute the
-Software only as embedded in the Application. You must not permit them
-to extract the Software from the Application or use it to develop
-software of their own.
-
-If you operate a service that embeds the Software and renders reports
-for your End Users, that service is an Application under section 1. You
-may run it royalty-free under this section, and you may put your license
-key in it as in any Application. Calling applications that only request
-renders from it need not incorporate the Software. People who use those
-applications only as End Users under section 1 get the pass-through
-rights above.
+## 3. Evaluation and development
 
-You may not:
+You may download, install and use the Software free of charge in any
+environment that is not a Deployment. That includes evaluation,
+prototypes, proofs of concept, and the development, staging, CI and
+test environments of an Application. This right covers the full
+feature set, needs no key, and has no time limit. The Software marks
+output that no License Key covers, as section 6 describes.
 
-- distribute the Software on its own, or as part of a product whose
-  primary purpose is to provide report-engine, report-design, or
-  document-generation capability to third-party developers;
-- expose the Software's APIs to third parties as a development tool or
-  service that substitutes for those parties buying their own Seats. A
-  licensee-operated service that embeds the Software and renders for
-  your own End Users falls outside that ban;
-- fork, mirror, repackage, rename, or wrap the Software, or republish
-  it on any package registry or code-hosting platform, other than as
-  embedded in an Application.
+This right does not let you use the Software in live business
+operations, or expose it in services that third parties use. Each
+Deployment needs a License Key under section 4.
+
+## 4. Deployment licenses
 
-For as long as this agreement is in force, you may not create any tool,
-library, product, or service that competes with the Software or any
-other Quario product, whether the competition is direct or indirect;
-this restriction does not survive termination. You may not remove or
-alter copyright or license notices in the Software. If your Application
-is itself a closed development product for third-party developers (OEM
-redistribution), contact us for separate terms.
+Each Deployment needs its own License Key, from the first day it runs
+in production. With that key in place:
 
-## 6. License keys and output marking
+- You may set the key in that Deployment and in the development,
+  staging, CI and test copies of that Deployment. The key then removes
+  the marking there too.
+- One key never covers two Deployments at the same time.
+- You may move a key to a new Deployment after the old Deployment no longer
+  runs the Software in production.
+- Contractors who work for you may use your keys for that work. They
+  may not use your keys for work they do for other clients.
 
-The Software accepts a license key that evidences your Seats under
-section 4. Key checks run offline.
+## 5. Use and pass-through
 
-Without a valid key, or with a key whose validity period does not cover
-the installed version's release date, the Software runs with its full
-feature set but marks its output as unlicensed. Using a key you are not
-entitled to is a material breach of this agreement.
+With a License Key under section 4 in place, you may operate the
+Application in its Deployment **royalty-free**. We charge no fees for
+servers, replicas, requests, renders, agents or End Users. You may
+embed your License Key in the Application.
 
-You may not remove, disable, or circumvent the key check or the output
+We grant you the right to pass through to each End User a limited,
+non-exclusive, non-transferable right to use the Software only as
+embedded in the Application that runs in your Deployment. You must not
+let End Users extract the Software from the Application or use it to
+develop software of their own.
+
+Calling applications that only request renders from your Deployment do
+not need to incorporate the Software. People who use those applications
+only as End Users get the pass-through rights above.
+
+You may not:
+
+- Distribute the Software on its own, or as part of a product whose
+  primary purpose is to give report-engine, report-design or
+  document-generation capability to third-party developers.
+- Expose the Software's APIs to third parties as a development tool or
+  service that replaces their own License Keys. A service you operate
+  that embeds the Software and renders for your own End Users is not
+  such a tool.
+- Fork, mirror, repackage, rename or wrap the Software, or republish it
+  on any package registry or code-hosting platform, other than as
+  embedded in an Application.
+
+**OEM distribution.** An Application that your customers install,
+embed or resell, and that runs the Software outside your control, is
+OEM distribution. A License Key does not cover OEM distribution, for
+any number of copies. Contact us for separate terms. When you render
+documents for your customers from a product that you host yourself,
+that product is a Deployment, not OEM distribution.
+
+While this agreement is in force, you may not create any tool,
+library, product or service that competes with the Software or with
+any other Quario product, directly or indirectly. This restriction
+ends when this agreement terminates. You may not remove or change
+copyright or license notices in the Software.
+
+## 6. License Keys and output marking
+
+The Software accepts a License Key as evidence of a Deployment's
+license under section 4. Key checks run offline.
+
+Each License Key states an end date. A key covers every release of the
+Software dated on or before that end date. Without a valid key, or with
+a key that does not cover the installed release, the Software runs with
+its full feature set but marks its output as unlicensed. A key that is
+void under section 7 licenses nothing, even where the installed
+release still accepts it. Use of a key that you have no right to use
+is a material breach of this agreement.
+
+A later release may refuse a key that we revoked. We revoke a key when
+we refund its payment, or when a chargeback or similar process
+reverses its payment. We also revoke a key that
+someone publishes for reuse by others. In that case, we give the
+licensee a free replacement key with the same end date. When you embed a
+key in your Application under section 5, that embedding alone does not
+publish the key for reuse.
+
+You may not remove, disable or bypass the key check or the output
 marking, or distribute anything that does.
 
-## 7. Term, updates, and perpetual fallback
+## 7. Term, updates and refunds
+
+**No subscription.** You pay once for each License Key. The key covers
+every release dated up to one year after you bought it, and you get
+support until that end date. We give support through our issue tracker
+and by email, with commercially reasonable effort. We do not guarantee
+response times.
+
+**Perpetual license.** Your license to the releases that a key covers
+is **perpetual**. The Deployment may keep using those releases, and
+the Application may keep running them, forever, at no further cost.
+Releases dated after the key's end date need a new key.
 
-Seats are sold as an annual subscription. While the subscription is
-active, licensed Developers receive all Software versions we release,
-and support for the Software through our issue tracker and by email. We
-provide support with commercially reasonable effort; we do not guarantee
-specific response times.
+**Renewal.** Renewal is a new purchase of a new key. It never occurs
+automatically, and we never charge you without a new order.
 
-If the subscription lapses, your license to the versions released during
-your subscription is **perpetual, for the number of Seats held at the
-lapse**: up to that many Developers may keep using those versions, and
-your Applications may keep shipping them, forever, at no further cost.
-Versions released after the lapse require renewal. We encode this rule
-in purchased keys: a key remains valid for every version released
-during its validity period, with no end date.
+**Refunds and reversals.** If we refund a payment, or a chargeback or
+similar process reverses a payment, each key that the payment
+bought is void. A partial refund states the keys that it voids. A void
+key gives you no rights, including no perpetual license. You keep the
+rights of section 3, and this agreement continues. Use of a void key in
+a Deployment is a material breach of this agreement. Keys that the
+refund or reversal does not void stay valid. If a payment dispute is
+decided in our favour, we restore the license with a reissued key.
 
 ## 8. Source availability
 
-The Software's packages ship with readable source code so that you can
+The Software's packages ship with readable source code, so you can
 review and debug what you run. Readable source does not grant extra
-rights: this agreement governs all use of the source, and you may
-publish the Software (modified or not) only as part of an Application
-under section 5.
+rights. This agreement governs all use of the source. You may publish
+the Software, modified or not, only as part of an Application under
+section 5.
 
-## 9. Ownership, trademarks, and feedback
+## 9. Ownership, trademarks and feedback
 
-We license the Software; we retain all intellectual property rights in
-it. Report definitions, data, and output you create with the Software
-are yours. "Quario" and the Quario logo are our trademarks; this
-agreement grants no rights to use them beyond identifying the Software.
-If you send us feedback or suggestions, we may use them without
-obligation.
+We license the Software. We keep all intellectual property rights in
+it. The report definitions, data and output that you create with the
+Software are yours. "Quario" and the Quario logo are our trademarks.
+This agreement grants no rights to use them, except to identify the
+Software. If you send us feedback or suggestions, we may use them
+without obligation.
 
 ## 10. Warranty and liability
 
@@ -181,11 +202,11 @@ We provide the Software as is. To the fullest extent the law allows, we
 disclaim all warranties and conditions, express or implied, including
 merchantability, fitness for a particular purpose, and non-infringement.
 
-To the fullest extent the law allows: we are not liable for indirect or
+To the fullest extent the law allows, we are not liable for indirect or
 consequential damages, loss of profits, loss of data, or business
-interruption; and our total aggregate liability under this agreement is
+interruption. Our total aggregate liability under this agreement is
 limited to the greater of EUR 100 and the fees you paid us in the
-twelve months preceding the event giving rise to the claim. These
+twelve months before the event that gave rise to the claim. These
 limitations do not apply where the damage results from the intent or
 deliberate recklessness (opzet of bewuste roekeloosheid) of us or our
 management, or where mandatory law does not permit them.
@@ -193,23 +214,24 @@ management, or where mandatory law does not permit them.
 ## 11. Termination and survival
 
 If you materially breach this agreement, we may terminate it by notice.
-If the breach can be remedied, we will first allow 30 days from that
-notice to remedy it, and termination takes effect only if the breach
-remains. On termination, the licenses granted here end.
-Perpetual-fallback rights under section 7 survive termination only if
-they arose from a lapse that predates the breach, and section 5
-survives with them to the extent needed to keep exercising them.
-Sections 8 through 12 survive any termination.
+If you can remedy the breach, we first give you 30 days from that
+notice to remedy it. Termination then occurs only if the breach
+continues. On termination, the licenses that this agreement grants end.
+The perpetual license to the releases that a key covers survives
+termination only if the end date of that key passed before the breach.
+Section 5 survives with it, as far as you need section 5 to use that
+license. Sections 8 through 12 survive any termination.
 
 ## 12. General
 
-Dutch law governs this agreement. Disputes go to the competent court for
-our registered office. You may not assign this agreement without our
-consent, except to a successor of your whole business; we may assign it
-to a successor of ours. If a provision is unenforceable, the remainder
-stays in force. Failure to enforce a provision does not waive it. This
-agreement, together with your order for Seats, is the entire agreement
-about the Software, unless we agree otherwise in writing.
+Dutch law governs this agreement. The competent court for our
+registered office decides disputes. You may not assign this agreement
+without our consent, except to a successor of your whole business. We
+may assign it to a successor of ours. If a provision is unenforceable,
+the remainder stays in force. If we do not enforce a provision, we do
+not waive it. This agreement, together with your order for License
+Keys, is the entire agreement about the Software, unless we agree
+otherwise in writing.
 
 ---
 

package/README.md

@@ -70,8 +70,8 @@ key verification as `{ licensed, licensee?, id? }`.
 
 ### `report(schema, functions?)`
 
-Compiles a report and returns the compiled report. `stream(data)` is the raw event generator.
-`render(target, data)` takes a self-naming `{ name, compile }` object from a target factory
+Compiles a report and returns the compiled report. `stream(data, params)` is the raw event generator, and `params` are the values this render supplies for what the document declares.
+`render(target, data, params)` takes a self-naming `{ name, compile }` object from a target factory
 (e.g. `html()` from `@quario/html`) or your own.
 
 A render is async: quario awaits key verification before the target sees its first event. A
@@ -209,6 +209,33 @@ validate({ data: "$.o[*]", sort: [{ by: "=@.a", dir: "up" }] });
 `report()` throws on the first problem instead. Validation and compilation share one traversal,
 so `validate()` can never disagree with what `report()` accepts.
 
+### JSON Schema
+
+The package ships a JSON Schema of the report document. Point `$schema` at the installed copy,
+and your editor checks the document and shows the documentation for each key:
+
+```json
+{
+  "$schema": "./node_modules/quario/lib/schema.json",
+  "data": "$.orders[*]",
+  "detail": [{ "type": "text", "value": "{{ @.product }}" }]
+}
+```
+
+The path is relative to the report file. The engine accepts the `$schema` key and does not read
+it.
+
+Code reads the same file through the package export:
+
+```js
+import schema from "quario/schema.json" with { type: "json" };
+```
+
+The JSON Schema proves the shape of each value. It does not replace `validate()`. Rules that
+join two or more values, and every expression and template, stay with `validate()`. Use the
+JSON Schema to constrain what an editor or a model writes. Use `validate()` to accept a
+document.
+
 ### `quario().plan(schema, functions?, { targets }?)`
 
 The one traversal, whole — for hosts that validate and render in a loop, like an editor. Returns

package/lib/format.js

@@ -94,7 +94,7 @@ let asMoney = (value, locale, decl, options, style) => {
 //
 // The form is Intl's own `dateStyle`, and it is always present: a declaration
 // that named none resolved to `medium` (docs/adr/0056). This is the half that
-// does not converge — the worksheet approximates it (CONTEXT.md, "Form").
+// does not converge — the worksheet approximates it (GLOSSARY.md, "Form").
 // `date` leads for the same reason the number kinds do, so the two key shapes
 // live beside each other and "one piece at a time" is auditable in one place.
 /** @type {(locale: string, decl: any, zone: string) => string} */