- keys set by only some switch branches are nullable where branches join, in $nodes and in graph output
- the (x ?? 0) fix is not offered in graph table cells and switch conditions, where an error means no match
- a graph first-hit row whose output can fail no longer makes later rows unreachable
- integer schema fields drop gaps without integers; min/max are read through nullable anyOf
- columns over the same field path ((x), x['y']) share one dimension; derived columns overlapping another column are left out of gap checks
Inside a decision-call cycle a recorded signature depends on which member was cut off as recursive, so comparing it could skip a dependent (seen when undoing an edit in a 3-graph cycle).
Cell text listed range tokens first ("> 5, null"); the VM evaluates list items left to right and a comparison throws on non-numbers, so null/string/bool values never matched. Compression and missing-case fixes produced cells that changed results. Switch conditions on date fields now narrow date columns by date instead of by string.
The table analysis now uses zen_expression::intellisense::values for what a condition accepts (interval/string/bool/null sets), parsing cells into constraints and printing sets back as cell text. ArmTest and the runtime decision table index are unchanged.
Edits queue their path; before the next snapshot the engine walks dependents with a frozen copy of every recorded view (each dependent on the graph stack) and stamps affected documents with a sequence. Consumers read them via changes_since(cursor), so queries in between cannot absorb a change. Graph dictionary views now cover the combined import list, matching first-wins resolution.
Typed edges (policy imports, graph dictionary imports, sub-decision signatures) maintained on set/remove; affected_by walks the index with early cutoff, and dictionary views cover the whole import chain.
Graph analyses record what they consume from other documents (called signatures, imported dictionaries) and stay valid while those values are unchanged; affected_by follows an edge only when the consumed value changed.
Remove full_table_check and the 2,000-row cap; table verification now runs fully in live diagnostics, with work caps only as a runaway guard.
- Per-column row index (string/bool keys, numeric segment tree) of live rows for unreachable checks and compression
- Witness-first reachability before computing covers; lazy borrowed coverers
- Divide-and-conquer missing cases over column partitions
- Allocation-free set intersection/subset checks and in-place merges for string cells
- Findings cache keyed by table content, so unchanged tables are not re-verified
- Identical cells type-checked once per column; linear output type merge and dictionary/linter grouping
Verify tables in policies and graphs (unreachable, duplicate, missing cases, compress), budgeted live checks with an on-demand full check, and quick-fix data for redundant parentheses and ?? fallbacks.
Without the arbitrary_precision feature, numbers were serialized through
to_u64/to_i64 first, which truncate, so 1.5 became 1 and 0.1 became 0.
Only integral values take the integer path now; the serialization for
Variable and RcValue shares one implementation.
* feat: declared dates as date values
- graph format:date/date-time inputs and policy date properties arrive as
dates that keep their original text for output, string() and string
functions
- d() keeps the instant of offset/Z strings, resolves DST gaps and accepts
ISO forms without offset, compact, slash-separated, YYYY-MM and YYYY
- dates compare with date strings in ==, !=, <, >, in and contains, and
concatenate with strings; deprecated date helpers accept dates
- string(date), type() reports date, and date-to-string at string inputs
* fix: close review gaps in date inputs
- parse new date formats by exact shape; keep master formats first and
guard DST-gap and extreme-year overflows
- text-carrying dates act as strings for object keys, in-object, index,
slice, concatenation and bool
- deprecated helpers fall back to the date instant; time() accepts dates
- schema-less child inputs receive date text; dates satisfy string
parameters and slicing in the type checker
- convert policy input before validation so dates are parsed once;
share rewrite helpers between graph and policy conversion
* fix: align date text, unions, references and child inputs
- every valid date exposes a text form (original or RFC3339), so string
functions and slicing on computed dates match the type checker
- date and string types merge to string; reference ids typed as dates
resolve through their text
- input nodes convert declared dates and hand every other converted date
back as its original text, following combinators only for structure
- date format checks no longer allocate
- graph input and output validation treats null optional properties as
absent (including inside anyOf/oneOf objects) and reports the real
error when validation still fails
- remove the NULLABILITY_DIVERGENCE diagnostic
- policies enforce required inputs also without goals; a path is missing
when absent or null unless a step along it is optional, checked after
reference hydration, and computed entity fields are not inputs
* 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
* fix: return errors instead of panicking in memory loader and v1 functions
- MemoryLoader recovers from a poisoned lock. Previously a panic during
one add() (e.g. a failing content conversion) made every later
add/get/remove/keys call panic for the rest of the process
- v1 function node returns an error when its JS bootstrap fails instead
of unwrapping. The 500ms interrupt budget starts before the runtime and
bundled libraries load, so a slow or loaded host could interrupt the
bootstrap and panic
* chore: bump setup-android to v3 in uniffi workflow
Only platform-tools is installed; Gradle fetches the platform and build tools the AAR build needs.
Ivan Miletic
Stefan
Ivan Miletic
GoRules Team
stefan-gorules