JRK.JevRunner
0.9.0
dotnet add package JRK.JevRunner --version 0.9.0
NuGet\Install-Package JRK.JevRunner -Version 0.9.0
<PackageReference Include="JRK.JevRunner" Version="0.9.0" />
<PackageVersion Include="JRK.JevRunner" Version="0.9.0" />
<PackageReference Include="JRK.JevRunner" />
paket add JRK.JevRunner --version 0.9.0
#r "nuget: JRK.JevRunner, 0.9.0"
#:package JRK.JevRunner@0.9.0
#addin nuget:?package=JRK.JevRunner&version=0.9.0
#tool nuget:?package=JRK.JevRunner&version=0.9.0
JRK.JevRunner
A .NET client for Jev and the TypeSafe System One API. Submit application state and named questions, and consume typed responses.
Upcoming changes (unreleased)
- Breaking: Runner initialization no longer accepts logging arguments. Configure logging
with
WithLoggerorWithLoggerFactoryafter initialization. - Implement
IJevQueryProcessRequestBeforeExecutionto customize generated requests immediately before execution;[JevQuery]is optional for these queries. - Inspect outgoing headers at debug level without exposing the Jev token in header diagnostics.
- Upload file-backed or byte-backed images as multipart data, or retain inline Base64.
- Prepare images independently and let generated queries register prepared asset properties.
- Send correctly serialized JSON with literal backtick references in payloads and debug logs.
- Breaking:
request.Execute(apiKey, ...)now acceptsILoggerFactoryrather thanILogger<JevRunner>. See initialization and logging for migration.
See the unreleased notes for details. The client still requires .NET 11 and preview C# features.
Requirements
- .NET 11 or later
- A TypeSafe API key
Installation
dotnet add package JRK.JevRunner
The package embeds its source generator and depends on JRK.JevRunner.Analyzers
for usage diagnostics and code fixes. NuGet installs that dependency automatically;
no separate analyzer reference is needed. Only the analyzer package contains the
usage-analyzer and code-fix DLLs, so adding a direct reference to that same package
does not introduce a second physical copy. These assemblies are compile-time assets
under analyzers/dotnet/cs/, not runtime assemblies, and target netstandard2.0,
while the client targets net11.0.
JEV100 warns when interpolating a state reference or path into a plain string loses
automatic backtick quoting. Its code fix wraps the interpolation in Escape.Interpolated(...)
to preserve and quote its arguments. JEV101 warns about redundant explicit backticks around
state references in preserved interpolations, with a fix to remove them.
See analyzer documentation
for examples and .editorconfig configuration.
The code fix emits the short helper name where safe, retaining namespace or root qualification only when needed to avoid name conflicts. Analysis also recognizes marker interfaces inherited through generic class constraints and constraint chains.
For repository development, analyzer project references are not transitive. Playground and the Image library explicitly reference the analyzer and code-fix projects. The Image NuGet package relies on its core package dependency for tooling rather than bundling duplicate assemblies. Pack the analyzer dependency before the client and publish both packages together. For local packaging checks:
dotnet pack JRK.JevRunner.Analyzers/JRK.JevRunner.Analyzers.csproj -c Release
dotnet pack JRK.JevRunner/JRK.JevRunner.csproj -c Release
dotnet build JRK.JevRunner.SourceGenerators/JRK.JevRunner.SourceGenerators.Sample/JRK.JevRunner.SourceGenerators.Sample.csproj -c Release -p:UsePackedJevRunner=true
dotnet pack JRK.JevRunner.Image/JRK.JevRunner.Image.csproj -c Release
dotnet build JRK.JevRunner.SourceGenerators/JRK.JevRunner.SourceGenerators.Sample/JRK.JevRunner.SourceGenerators.Sample.csproj -c Release -p:UsePackedJevRunner=true -p:UseImageOnly=true
dotnet build JRK.JevRunner.SourceGenerators/JRK.JevRunner.SourceGenerators.Sample/JRK.JevRunner.SourceGenerators.Sample.csproj -c Release -p:UsePackedJevRunner=true -p:IncludeImagePackage=true
dotnet build JRK.JevRunner.SourceGenerators/JRK.JevRunner.SourceGenerators.Sample/JRK.JevRunner.SourceGenerators.Sample.csproj -c Release -p:UsePackedJevRunner=true -p:IncludeImagePackage=true -p:IncludeStandaloneAnalyzers=true
These build-only smoke checks compile generated queries and assert exactly one resolved
usage-analyzer, code-fix, and source-generator assembly for core alone, Image alone,
core plus Image, and an additional direct analyzer reference. They use local package feeds and the current
version settings; -p:JevRunnerPackageVersion=... overrides the consumed version.
Use a new package version for each published fix; replacing an existing version can
leave consumers or IDEs using cached assemblies.
Package restores audit both direct and transitive dependencies and fail on known vulnerabilities or audit-feed failures. To repeat the advisory check:
dotnet restore all.slnx --force-evaluate
dotnet package list --project all.slnx --vulnerable --include-transitive --no-restore
Quick start
Set the TYPESAFE_API_KEY environment variable to your API key. Do not commit API keys to source control.
using JRK.JevRunner;
using JRK.JevRunner.Requests;
var apiKey = Environment.GetEnvironmentVariable("TYPESAFE_API_KEY")
?? throw new InvalidOperationException("Set TYPESAFE_API_KEY before running.");
var runner = JevRunner.Init(apiKey);
var request = new Request("The brown fox jumped over the lazy dog.", JevModel.Latest)
.AddQuestion(new NoulQuestionBuilder(
"dog_was_jumped_over",
"Did any animal jump over a lazy dog?"));
var response = await runner.Execute(request);
Console.WriteLine(response.GetRequiredNoulAnswer("dog_was_jumped_over"));
Initialization and logging
JevRunner.Init(apiKey) uses no-op logging. To receive diagnostics, call
WithLoggerFactory or WithLogger on the initialized runner:
var runner = JevRunner.Init(apiKey).WithLoggerFactory(loggerFactory);
var runnerWithTypedLogger = JevRunner.Init(apiKey).WithLogger(logger);
InitFromEnvironmentVariable reads JEV_TOKEN by default, or a custom variable:
var runner = JevRunner.InitFromEnvironmentVariable().WithLoggerFactory(loggerFactory);
var customRunner = JevRunner.InitFromEnvironmentVariable("TYPESAFE_API_KEY")
.WithLogger(logger);
A missing variable throws InvalidOperationException; an empty or whitespace-only
API key throws ArgumentException. For no-op logging, omit the WithLogger
or WithLoggerFactory call.
For dependency injection or a custom HTTP pipeline, use the public constructor
with JevOptions, HttpClient, and ILogger<JevRunner>.
At debug level, the runner logs the request JSON and a snapshot of outgoing
headers immediately before sending. The snapshot includes client-default,
request-specific, and content headers, with request-specific values overriding
defaults. It does not include headers added later by handlers or the transport.
Authorization, Proxy-Authorization, Cookie, JevToken, and X-Api-Key
values are replaced with [REDACTED]; occurrences of the configured API key in
other header values are also redacted before entering the logging pipeline.
The actual HTTP headers are unchanged. Request JSON logging is not redacted:
avoid placing secrets in request state or instructions.
Migration: request.Execute(apiKey, loggerFactory) now takes an
ILoggerFactory instead of a typed logger. To retain an existing typed logger:
var runner = JevRunner.Init(apiKey).WithLogger(logger);
var response = await runner.Execute(request, cancellationToken);
Reference properties in instructions
Use state.GetPath(s => s.Items[0].Name) to build a reference from a property
selector instead of typing the path by hand. For a root array, a selector such
as s => s[0].Name produces [0].Name. Selectors support instance properties
and non-negative constant array indexes. They are not executed, and the path
uses CLR property names, so make sure those names match the JSON sent to Jev.
For reusable instructions, derive from Instruction to reference properties
on the instruction object, or use InstructionWithState<TState> to also
reference properties on the request state:
using JRK.JevRunner.Requests;
public sealed record TicketState(string Subject);
public sealed class MatchSubject : InstructionWithState<TicketState>
{
public MatchSubject(string expectedSubject)
{
ExpectedSubject = expectedSubject;
Question = FormatInstruction(
$"Does {GetStatePath(state => state.Subject)} match {GetInstructionPath(() => ExpectedSubject)}?");
}
public string ExpectedSubject { get; }
public string Question { get; }
}
FormatInstruction produces "Does Subject match ExpectedSubject?" without
inserting either property value. Pass the instruction object, not just its
Question string, to include ExpectedSubject alongside the question.
Supply the TicketState separately as the request state.
Custom backtick-quoted references
The public IBackTick interface lets you create domain-specific reference types
that receive the same automatic quoting as StateReference and StatePath.
Implement Value; the default BackTickQuoted implementation wraps it in backticks.
using JRK.JevRunner;
var reference = new TicketReference("ticket.messages[0].text");
var instructions = Escape.Interpolated($"Summarize {reference}.");
// Summarize `ticket.messages[0].text`.
public sealed record TicketReference(string Value) : IBackTick;
Pass the interpolation directly to Escape.Interpolated(...), or preserve it as a
FormattableString and use .Escaped. Converting it to a plain string first loses
automatic quoting. Do not add explicit backticks around the interpolation. The
JEV100 and JEV101 analyzers also recognize custom IBackTick implementations.
Custom implementations are responsible for validating their values: IBackTick
does not reject whitespace or embedded backticks, unlike the built-in reference
types. This interface only controls instruction formatting; it does not register
state fields or resolve references against request state.
Models and request validation
Requests without an explicit model use JevModel.Latest, including requests with
Box questions. An explicitly supplied model is never overridden. Box questions
require jev-1.14.0 or later; JevModel.Preview remains available as an explicit choice.
JevVersions provides Latest, Preview, Version1_13_0, and Version1_14_0
string constants and the known-version list Versions. Inspect a JevModel with
IsLatest, IsPreview, IsKnownVersion, or IsVersion(version).
Request.StrictValidation defaults to false. Before sending a request, the
runner logs a warning for an unknown model identifier or for Box questions using
jev-1.13.0, but still sends the request. Set StrictValidation = true to throw
InvalidOperationException for either condition before any HTTP request:
var request = new Request("Application state", JevModel.Latest)
{
StrictValidation = true
};
The bundled known-version list may lag the API: an unknown identifier is not necessarily unsupported by TypeSafe. These checks do not replace API validation or guarantee that a request is valid.
Long context (opt-in)
Set request.LongContextEnabled = true or call the chainable
request.EnableLongContext() extension from JRK.JevRunner to send
TypeSafe-Danger-Zone-Long-Context: true for that request. The default is disabled.
var request = new Request("Application state", JevModel.Latest)
.EnableLongContext()
.AddQuestion(new NoulQuestionBuilder("ready", "Is the application ready?"));
This opts into context beyond TypeSafe's default 64 KB limit. TypeSafe cautions that longer context is slower and less accurate than staying within the default limit; enable it only for requests that need it. Other API limits still apply.
Images (experimental)
Jev's image API is dreamer-ready, not production-ready: request formats, limits,
and accuracy may change. Images can be used with Noul, Choice, Score, and Box
questions. Box answers contain normalized Top, Bottom, Left, and Right
edges and answer-level Confidence.
Use AssetState to associate a state field with an image. FilePathAsset opens
the file when executing the request and uploads it as multipart data. It uses the
file extension as the format and accepts an optional IFileSystem for file access.
Using the runner initialized in the quick start:
using JRK.JevRunner;
using JRK.JevRunner.Infrastructure;
using JRK.JevRunner.Requests;
using TruePath;
var imagePath = AbsolutePath.Create(Path.GetFullPath("photo.jpg"));
var image = new FilePathAsset(imagePath)
.WithAssetName(Guid.NewGuid().ToString());
var state = new AssetState().AddAsset("photo", image);
var request = new Request(state, JevModel.Latest)
.AddQuestion(new NoulQuestionBuilder(
"person_present",
"Is there a person in `photo`?"));
var response = await runner.Execute(request);
Console.WriteLine(response.GetRequiredNoulAnswer("person_present").Noul);
Populate the state before constructing the request: its assets are collected by the constructor. Keep file-backed sources available until execution completes. A generated query can register prepared asset properties automatically; see prepared assets in generated queries.
For manual configuration, add an ImageAsset(reference, format, bytes) to
request.Assets and place the same reference in the state, instructions, or
criteria. Use unique references such as UUIDs to avoid accidental text matches.
For already encoded data, pass new Base64String(base64) instead of bytes.
Base64 must contain only the encoded bytes, without a data: prefix.
Requests containing assets automatically send
TypeSafe-Danger-Zone-Images: true. ImageAsset embeds Base64 in the JSON assets
map. FilePathAsset, ByteArrayAsset, and custom IImageStreamAsset implementations
trigger multipart upload: the first part is JSON named request, followed by
application/octet-stream image parts. Inline and stream-backed assets can coexist.
The runner disposes opened upload streams. A filename or image URL alone does not
upload an image.
Stream asset AssetName identifies the entry in state and the JSON assets map;
Name identifies the multipart field referenced by the JSON part value.
Use Asset.AssetName when working with the asset union, and Asset.ReadAsBytes()
to read either inline or stream-backed contents.
Migration: AddImageAsset now requires base64Encode and returns a
ValueTask. Pass true to preserve inline Base64 behavior:
await state.AddImageAsset("anotherPhoto", Guid.NewGuid().ToString(),
imagePath, base64Encode: true);
Passing false creates a file-backed asset with a generated reference; that branch
does not use the supplied assetName. For an explicit reference, use
FilePathAsset.WithAssetName(...) as above.
Prepare PNG or JPEG images before sending: each dimension must be 280–1568 pixels,
each file at most 16 MiB, and the request body at most 32 MiB. Base64 increases the
body size. Rotate the pixels upright; the API does not apply EXIF orientation.
The helper does not resize, rotate, convert, or validate image data. Use a lowercase
.png, .jpg, or .jpeg extension that matches the file contents.
For an explicit per-file check before upload, use ImageValidator from the optional
JRK.JevRunner.Image package. Or see Validate and prepare images.
See the TypeSafe image documentation for all limits.
Validate and prepare images
The optional JRK.JevRunner.Image package provides ImageValidator, proportional
ImageScaler.Upscale/Downscale, and experimental automatic asset adjustment.
Validation returns typed dimension or string errors and a result-level
SuggestedScaling; call ThrowIfInvalid() to reject a failed validation.
Suggestions only describe dimension-error direction and do not guarantee that
resizing will make an image valid. See the image preparation examples and limitations.
To register already-prepared bytes without writing another file:
byte[] imageBytes = new JRK.JevRunner.Image.ImageScaler().Downscale(
AbsolutePath.Create(@"C:\images\photo.jpg"));
var state = new AssetState().AddAsset("photo",
new ImageAsset(Guid.NewGuid().ToString(), "png", imageBytes));
ImageScaler returns PNG bytes. ImageAsset accepts them through FileData,
which exposes Bytes and Base64; the constructor does not validate or convert
the supplied format. For multipart upload instead, use:
var reference = Guid.NewGuid().ToString();
var multipartState = new AssetState().AddAsset("photo",
new ByteArrayAsset(imageBytes, "photoPart", "photo.png", reference, "png"));
The optional image package also provides synchronous
path.CreateAssetWithAdjustments("photo"): it validates and attempts one suggested
resize, returning an AssetAndStateReference without registering it. Unchanged
images remain file-backed; resized images become byte-backed PNGs. Use
state.AddAssetStateAndReference(prepared) to register the result manually.
Adjusted output is not revalidated. AddImageAssetWithAutoAdjustment is now
synchronous too; remove await from existing calls.
Locate objects with Box questions
Using the populated state above:
var request = new Request(state)
.AddQuestion(new BoxQuestionBuilder("Head", "Find the head in `photo`."));
var response = await runner.Execute(request);
var head = response.GetRequiredBoxAnswer("Head");
Console.WriteLine($"Top: {head.Top}, left: {head.Left}, confidence: {head.Confidence.Value}");
Without an explicit model, execution selects JevModel.Latest, including for Box
questions added after construction. An explicitly supplied model is never overridden.
Box questions require jev-1.14.0 or later; see request validation.
For generated queries, expose a GenericBoxQuestionDefinition<string> property
or implement IBoxQuestionDefinition<TInstruction>. A question property named
Head generates GetHeadAnswer(response) and a BoxAnswer property named Head
on the response wrapper. See the generator's Box example.
Render bounding boxes
The optional JRK.JevRunner.Image package provides a SkiaSharp BoxRenderer.
The core client does not depend on it. With the original image path and a Box answer:
using JRK.JevRunner.Image;
var imagePath = AbsolutePath.Create(Path.GetFullPath("photo.jpg"));
byte[] png = new BoxRenderer().DrawBox(imagePath, head);
await File.WriteAllBytesAsync("annotated.png", png);
DrawBox accepts one BoxAnswer or an IEnumerable<BoxAnswer> through AppliedBox,
and returns PNG bytes without modifying the source. Multiple boxes share the supplied
color and stroke width. See the image package documentation
for styling, coordinate validation, native dependencies, and multi-box examples.
API errors
Known HTTP errors throw JevKnownException from JRK.JevRunner.Infrastructure.
Its InnerException retains the original HttpRequestException, including the
status code, and its nullable Content exposes the response body as an
ErrorContent union (JsonNode or string). Empty or whitespace-only bodies
produce null content.
using JRK.JevRunner.Infrastructure;
try
{
var response = await runner.Execute(request);
}
catch (JevKnownException error)
{
Console.Error.WriteLine(error.Message);
if (error.InnerException is HttpRequestException httpError)
Console.Error.WriteLine($"HTTP status: {httpError.StatusCode}");
if (error.Content is { } content)
Console.Error.WriteLine(content.Value);
}
Handled status codes are 400, 401, 413, 415, 422, 429, and 529, with 509 retained for compatibility. Other status codes pass through as HTTP exceptions regardless of whether their response body is JSON or plain text. Transport failures pass through without an HTTP response. The client does not automatically retry rate-limit or overload responses.
Non-empty error bodies are parsed as JSON when possible. Plain text, malformed JSON, and JSON null are retained as raw strings rather than masking the HTTP failure with a JSON parsing exception.
See the TypeSafe error-code documentation.
Samples
See the samples and run instructions for runnable examples, including:
- AnimalQuiz: identify a hidden animal through yes-or-no questions in an interactive console game.
- BlackJack (Halvtolv): play a Danish blackjack variant against a Jev-controlled dealer that reasons about visible cards and round history to decide whether to stop or draw.
- FileGrouping: classify files with Jev and move them into category folders.
- FileImageAnalyzer: analyze local photos for pets, children, and screenshots, and display images with a child bounding box.
Generated queries
Alternatively you can mark a partial class or record class with [JevQuery], or implement
IJevQueryProcessRequestBeforeExecution without the attribute. Supply a readable
State property and optionally JevModel; omitting the model uses automatic selection.
State can be a string, array or any object. Question properties implement one of
INoulQuestionDefinition<TInstruction>, IChoiceQuestionDefinition<TInstruction>,
IScoreQuestionDefinition<TInstruction>, or IBoxQuestionDefinition<TInstruction> from JRK.JevRunner.Annotation.
The generator adds GetRequest(), Execute(runner, cancellationToken), and named
typed answer accessors such as GetBudgetAnswer(Response). Generated Execute
returns Task<{QueryName}ResponseWrapper>. The wrapper exposes getter-only typed
answer properties named after the query's questions and the original .Response.
For example, using the runner initialized in the quick start:
using JRK.JevRunner.Annotation;
using JRK.JevRunner.Requests;
var query = new AnimalQuery();
var result = await query.Execute(runner);
Console.WriteLine(result.DogJumpedOver);
var response = result.Response; // Original Response for direct runtime API access.
[JevQuery]
public partial class AnimalQuery
{
public string State => "The brown fox jumped over the lazy dog.";
public JevModel JevModel => global::JRK.JevRunner.Requests.JevModel.Latest;
public JumpQuestion DogJumpedOver { get; } = new();
}
public class JumpQuestion : INoulQuestionDefinition<string>
{
public string Instructions => "Did any animal jump over a lazy dog?";
public string? Yes => "An animal jumped over a lazy dog.";
public string? No => "No animal jumped over a lazy dog.";
}
Execute(runner, cancellationToken) builds the request and forwards the optional
cancellation token to the runner. In this example it returns an
AnimalQueryResponseWrapper with a NoulAnswer property named DogJumpedOver.
GetRequest() and GetDogJumpedOverAnswer(Response) remain available for manual
execution and answer lookup. Wrapper answer properties throw if an answer is
missing or has a mismatched type.
Criteria are generated only when both Yes and No are non-null; otherwise
criteria remain unset.
Prepared assets in generated queries
Expose readable AssetAndStateReference properties and declare State as
AssetState (or a derived type). Generated GetRequest() registers non-null
properties before constructing the request:
using JRK.JevRunner.Annotation;
using JRK.JevRunner.Image;
using JRK.JevRunner.Infrastructure;
using TruePath;
[JevQuery]
public partial class PhotoQuery
{
public AssetState State { get; } = new();
public AssetAndStateReference Photo { get; } =
AbsolutePath.Create(Path.GetFullPath("photo.jpg"))
.CreateAssetWithAdjustments("photo");
}
Add question-definition properties as with other queries. For their instructions,
Escape.Interpolated($"Describe {Photo}.") produces Describe `photo`..
Repeated calls reuse identical registrations; different assets or values at the
same state field throw InvalidOperationException. Keep prepared properties
stable rather than creating a new asset on each getter call.
JEV007 warns when the declared State type does not inherit from AssetState;
the generator then ignores prepared asset properties. Derived state types and
generic state types constrained to AssetState are supported. Calling GetRequest()
registers assets but does not invoke the preprocessing hook below.
Customize a generated request before execution
Implement IJevQueryProcessRequestBeforeExecution to modify the completed request
or return a replacement. The class must still be partial and satisfy the query
contract, but does not need [JevQuery]:
public partial class LongContextQuery : IJevQueryProcessRequestBeforeExecution
{
public string State => "Application state requiring long context.";
public JumpQuestion DogJumpedOver { get; } = new();
public Request ProcessRequestBeforeExecution(Request request) =>
request.EnableLongContext();
}
Generated Execute invokes this hook once, after adding all questions and
immediately before calling IJevRunner.Execute. The returned request and the
original cancellation token are passed to the runner. Explicit interface
implementations are supported. If the hook throws, execution fails without
calling the runner. Calling GetRequest() alone does not invoke the hook.
Question attributes have been replaced by definition interfaces. Choice definitions
provide ChoiceCriteria[] Choices; score definitions provide string[] Criterias
and now have only the instruction generic parameter. Noul definitions provide
optional Yes and No descriptions: both must be non-null to generate criteria.
If either is null, the runtime omits the JSON criteria member.
See the generator contract and diagnostics and the mixed-query sample.
This package is targeting C# 15 and dotnet sdk which is currently in the time of writing in preview
Dependency notes
This library uses TruePath.TestableIO.System.IO,
which builds on TruePath and
TestableIO.System.IO.
License
MIT License. Copyright (c) 2026 Jeppe Roi Kristensen.
| Product | Versions Compatible and additional computed target framework versions. |
|---|---|
| .NET | net11.0 is compatible. |
-
net11.0
- JRK.JevRunner.Analyzers (>= 0.9.0)
- TruePath.TestableIO.System.IO (>= 1.1.0)
NuGet packages (1)
Showing the top 1 NuGet packages that depend on JRK.JevRunner:
| Package | Downloads |
|---|---|
|
JRK.JevRunner.Image
Optional SkiaSharp image helpers for JRK.JevRunner. Validate image files, proportionally upscale or downscale them, and render normalized Jev bounding-box answers without modifying source files. |
GitHub repositories
This package is not used by any popular GitHub repositories.
| Version | Downloads | Last Updated |
|---|---|---|
| 0.9.0 | 95 | 11/19/2026 |
| 0.8.0 | 110 | 11/17/2026 |
| 0.7.2 | 98 | 11/9/2026 |
| 0.7.1 | 102 | 11/5/2026 |
| 0.7.1-preview-01 | 95 | 11/5/2026 |
| 0.7.1-dev-02 | 91 | 11/5/2026 |
| 0.7.0 | 100 | 11/4/2026 |
| 0.6.0 | 116 | 10/26/2026 |
| 0.6.0-preview-01 | 106 | 10/25/2026 |
| 0.5.0 | 107 | 10/19/2026 |
| 0.5.0-preview-02 | 99 | 10/19/2026 |
| 0.5.0-preview-01 | 103 | 10/18/2026 |
| 0.4.0 | 112 | 10/17/2026 |
| 0.3.1 | 101 | 10/11/2026 |
| 0.3.0 | 98 | 10/11/2026 |
| 0.3.0-preview-01 | 98 | 10/11/2026 |
| 0.2.0 | 104 | 10/10/2026 |
| 0.2.0-preview-01 | 111 | 10/10/2026 |
| 0.1.0 | 104 | 10/9/2026 |
| 0.0.3 | 103 | 10/9/2026 |
Reusable instructions, typed state paths, and question factories
- Compose instructions with Instruction and InstructionWithState using GetInstructionPath, GetStatePath, and FormatInstruction for automatic backtick quoting.
- Build property and constant array paths from typed selectors without reading values, including for root arrays.
- Create Noul, Box, Choice, and Score definitions with QuestionDefinition factories; use the Interpolated variants to preserve reference arguments.