* feat: implement slots instead of natural language
Replace the natural-language projection (`nl`) with engine-owned slot
completion: for a cursor position the engine classifies the slot being
edited (operand, operator, literal, member access, ...) and returns typed
options, literal facts and the expected type, for policies and graphs.
- zen-expression: new `slot` module (classification, literals, operators)
and a lenient lexer mode for incomplete input; `nl` removed
- Intellisense: typed diagnostic codes with arguments, richer inspect for
hover, dedicated parser error variants (messages unchanged)
- Engine: `Workspace::cursor_scope`, `slot`, `facts`; `rename_from` and
`references_from`; editor spans in UTF-16 units; renames reach imported
policies, `$nodes` reads, child graphs and output column heads; no `$root`
completion in policies
- Node bindings: `slot`, `facts`, `cursorScope`, `slotBatch` replace
`nl`, `nlTokenize`, `nlEncodeString`, `nlTokenizeBatch`
No change to expression evaluation: the VM, compiler, functions and the
default lexer path are untouched, and parser error messages keep their text.
* fix: harden slot classification, scopes and graph expectations
- restore master execution order; slot scopes hide writes of the edited
block and its dependents instead of relying on block ranking
- token-start editing gated by slot state; operator, list and operand
spans no longer splice into neighbouring tokens
- interval-aware bracket pairing for half-open and reversed intervals
- lenient lexer recovers from unknown characters (slots only)
- graph expected type follows switch and pass-through nodes and merges
compatible output schemas
- sibling inference caps distinct values and analyses lazily
- deterministic overload return type display
* fix: order policy blocks by entity reads through closures and relationships
- record reads for `#.field` in closures so entity fields read through
lists become dependencies
- link reads through derived lists (filter/map results) to the entity
fields they carry and order the list after those fields
- evaluate entity blocks on single relationships, and demand entity
paths for plain reads through relationships
- slot scopes keep the top-level variable when hiding written fields
* fix: scope policy evaluation to the import closure
A policy is now analysed and evaluated together with the policies it
imports (transitively), instead of every policy connected to it by imports
in either direction. Importers and siblings no longer leak into each other:
compiled evaluate() of an imported policy used to run its importers' and
siblings' blocks.
- Evaluation gate analyses the entry's import closure as one unit, so a
child may read fields and reference entities its importer declares when
evaluated through that importer
- compile() reports a policy that is only valid through an importer with
kind "policyImportOnly" instead of failing it as a plain "policy"; errors
are computed once per key
- Scope diagnostics (duplicate writers, input overrides, data model and
dictionary collisions, cycles) are reported for the whole closure, and
conflicts introduced by combining imports are reported on the importer
- Single-entity scope checks run per import closure instead of workspace-wide
* fix: unknown import relationship targets and renames across imports
- An unresolved relationship/reference target inside an imported policy now
blocks the importer's evaluation and compile(), as on master; the check was
still limited to the policy being analysed, so the importer compiled and
the broken child was reported as "policyImportOnly"
- Rename and find-references analyse each policy's expressions in every
importer's context too, so reads of a field declared by an importer are
found in the imported policy again
Ivan Miletic
stefan-gorules