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.
GoRules Team
stefan-gorules
Ivan Miletic