@getodk/xforms-engine 0.1.0 → 0.2.0

package/dist/instance/abstract/InstanceNode.d.ts

@@ -1,20 +1,22 @@
-import type { XFormsXPathEvaluator } from '@getodk/xpath';
-import type { Accessor, Signal } from 'solid-js';
-import type { BaseNode } from '../../client/BaseNode.ts';
-import type { InstanceNodeType } from '../../client/node-types.ts';
-import type { TextRange } from '../../index.ts';
-import type { CurrentState } from '../../lib/reactivity/node-state/createCurrentState.ts';
-import type { EngineState } from '../../lib/reactivity/node-state/createEngineState.ts';
-import type { SharedNodeState } from '../../lib/reactivity/node-state/createSharedNodeState.ts';
-import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
-import type { SimpleAtomicState } from '../../lib/reactivity/types.ts';
-import type { AnyNodeDefinition } from '../../model/NodeDefinition.ts';
-import type { Root } from '../Root.ts';
-import type { AnyChildNode, AnyNode, AnyParentNode } from '../hierarchy.ts';
-import type { NodeID } from '../identity.ts';
-import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
-import type { InstanceConfig } from '../internal-api/InstanceConfig.ts';
-import type { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';
+import { XFormsXPathEvaluator } from '@getodk/xpath';
+import { Accessor, Signal } from 'solid-js';
+import { BaseNode } from '../../client/BaseNode.ts';
+import { NodeAppearances } from '../../client/NodeAppearances.ts';
+import { InstanceNodeType } from '../../client/node-types.ts';
+import { TextRange } from '../../index.ts';
+import { CurrentState } from '../../lib/reactivity/node-state/createCurrentState.ts';
+import { EngineState } from '../../lib/reactivity/node-state/createEngineState.ts';
+import { SharedNodeState } from '../../lib/reactivity/node-state/createSharedNodeState.ts';
+import { ReactiveScope } from '../../lib/reactivity/scope.ts';
+import { SimpleAtomicState } from '../../lib/reactivity/types.ts';
+import { AnyNodeDefinition } from '../../model/NodeDefinition.ts';
+import { Root } from '../Root.ts';
+import { AnyChildNode, AnyNode, AnyParentNode } from '../hierarchy.ts';
+import { NodeID } from '../identity.ts';
+import { EvaluationContext } from '../internal-api/EvaluationContext.ts';
+import { InstanceConfig } from '../internal-api/InstanceConfig.ts';
+import { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';
+
 export interface InstanceNodeStateSpec<Value = never> {
     readonly reference: Accessor<string> | string;
     readonly readonly: Accessor<boolean> | boolean;
@@ -27,9 +29,6 @@ export interface InstanceNodeStateSpec<Value = never> {
     readonly value: Signal<Value> | SimpleAtomicState<Value> | null;
 }
 type AnyInstanceNode = InstanceNode<AnyNodeDefinition, InstanceNodeStateSpec<any>, any>;
-interface InitializedStateOptions<T, K extends keyof T> {
-    readonly uninitializedFallback: T[K];
-}
 /**
  * This type has the same effect as {@link MaterializedChildren}, but abstractly
  * handles leaf node types as well.
@@ -37,52 +36,52 @@ interface InitializedStateOptions<T, K extends keyof T> {
 export type InstanceNodeCurrentState<Spec extends InstanceNodeStateSpec<any>, Child> = CurrentState<Omit<Spec, 'children'>> & {
     readonly children: [Child] extends [AnyChildNode] ? readonly Child[] : null;
 };
+interface ComputableReferenceNode {
+    readonly parent: AnyParentNode | null;
+    readonly definition: AnyNodeDefinition;
+}
+type ComputeInstanceNodeReference = <This extends ComputableReferenceNode>(this: This, parent: This['parent'], definition: This['definition']) => string;
+export interface InstanceNodeOptions {
+    readonly computeReference?: () => string;
+}
 export declare abstract class InstanceNode<Definition extends AnyNodeDefinition, Spec extends InstanceNodeStateSpec<any>, Child extends AnyChildNode | null = null> implements BaseNode, EvaluationContext, SubscribableDependency {
     readonly engineConfig: InstanceConfig;
     readonly parent: AnyParentNode | null;
     readonly definition: Definition;
-    protected readonly isStateInitialized: Accessor<boolean>;
     protected abstract readonly state: SharedNodeState<Spec>;
     protected abstract readonly engineState: EngineState<Spec>;
     /**
-     * Provides a generalized mechanism for accessing a reactive state value
-     * during a node's construction, while {@link engineState} is still being
-     * defined and thus isn't assigned.
-     *
-     * The fallback value specified in {@link options} will be returned on access
-     * until {@link isStateInitialized} returns true. This ensures:
-     *
-     * - a value of the expected type will be available
-     * - any read access will become reactive to the actual state, once it has
-     *   been initialized and {@link engineState} is assigned
-     *
-     * @todo This is one among several chicken/egg problems encountered trying to
-     * support state initialization in which some aspects of the state derive from
-     * other aspects of it. It would be nice to dispense with this entirely. But
-     * if it must persist, we should also consider replacing the method with a
-     * direct accessor once state initialization completes, so the initialized
-     * check is only called until it becomes impertinent.
+     * @package Exposed on every node type to facilitate inheritance, as well as
+     * conditional behavior for value nodes.
+     */
+    abstract readonly hasReadonlyAncestor: Accessor<boolean>;
+    /**
+     * @package Exposed on every node type to facilitate inheritance, as well as
+     * conditional behavior for value nodes.
      */
-    protected getInitializedState<K extends keyof EngineState<Spec>>(key: K, options: InitializedStateOptions<EngineState<Spec>, K>): EngineState<Spec>[K];
+    abstract readonly isReadonly: Accessor<boolean>;
     /**
      * @package Exposed on every node type to facilitate inheritance, as well as
      * conditional behavior for value nodes.
      */
-    get isReadonly(): boolean;
+    abstract readonly hasNonRelevantAncestor: Accessor<boolean>;
     /**
      * @package Exposed on every node type to facilitate inheritance, as well as
      * conditional behavior for value nodes.
      */
-    get isRelevant(): boolean;
+    abstract readonly isRelevant: Accessor<boolean>;
     readonly nodeId: NodeID;
     abstract readonly nodeType: InstanceNodeType;
+    abstract readonly appearances: NodeAppearances<Definition>;
     abstract readonly currentState: InstanceNodeCurrentState<Spec, Child>;
     abstract readonly root: Root;
     abstract readonly evaluator: XFormsXPathEvaluator;
     readonly scope: ReactiveScope;
-    get contextReference(): string;
+    readonly computeReference: ComputeInstanceNodeReference;
+    protected readonly computeChildStepReference: ComputeInstanceNodeReference;
+    readonly contextReference: () => string;
     abstract readonly contextNode: Element;
-    constructor(engineConfig: InstanceConfig, parent: AnyParentNode | null, definition: Definition);
+    constructor(engineConfig: InstanceConfig, parent: AnyParentNode | null, definition: Definition, options?: InstanceNodeOptions);
     /**
      * @package This presently serves a few internal use cases, where certain
      * behaviors depend on arbitrary traversal from any point in the instance
@@ -94,9 +93,8 @@ export declare abstract class InstanceNode<Definition extends AnyNodeDefinition,
      * interface for those internal uses.
      */
     abstract getChildren(this: AnyInstanceNode): readonly AnyChildNode[];
-    protected abstract computeReference(parent: AnyInstanceNode | null, definition: Definition): string;
-    getNodeByReference(this: AnyNode, visited: WeakSet<AnyNode>, dependencyReference: string): SubscribableDependency | null;
-    getSubscribableDependencyByReference(this: AnyNode, reference: string): SubscribableDependency | null;
+    getNodesByReference(this: AnyNode, visited: WeakSet<AnyNode>, dependencyReference: string): readonly SubscribableDependency[];
+    getSubscribableDependenciesByReference(this: AnyNode, reference: string): readonly SubscribableDependency[];
     /**
      * This is a default implementation suitable for most node types. The rest
      * (currently: `Root`, `RepeatRange`, `RepeatInstance`) should likely extend

package/dist/instance/children.d.ts

@@ -1,2 +1,3 @@
-import type { GeneralChildNode, GeneralParentNode } from './hierarchy.ts';
+import { GeneralChildNode, GeneralParentNode } from './hierarchy.ts';
+
 export declare const buildChildren: (parent: GeneralParentNode) => GeneralChildNode[];

package/dist/instance/hierarchy.d.ts

@@ -1,10 +1,11 @@
-import type { Group } from './Group.ts';
-import type { RepeatInstance } from './RepeatInstance.ts';
-import type { RepeatRange } from './RepeatRange.ts';
-import type { Root } from './Root.ts';
-import type { SelectField } from './SelectField.ts';
-import type { StringField } from './StringField.ts';
-import type { Subtree } from './Subtree.ts';
+import { Group } from './Group.ts';
+import { RepeatInstance } from './RepeatInstance.ts';
+import { RepeatRange } from './RepeatRange.ts';
+import { Root } from './Root.ts';
+import { SelectField } from './SelectField.ts';
+import { StringField } from './StringField.ts';
+import { Subtree } from './Subtree.ts';
+
 export type AnyNode = Root | Group | Subtree | RepeatRange | RepeatInstance | StringField | SelectField;
 export type AnyParentNode = Root | Group | Subtree | RepeatRange | RepeatInstance;
 export type GeneralParentNode = Root | Group | Subtree | RepeatInstance;

package/dist/instance/index.d.ts

@@ -1,6 +1,7 @@
-import type { RootNode } from '../client/RootNode.ts';
-import type { InitializeFormOptions as BaseInitializeFormOptions, FormResource } from '../client/index.ts';
-import type { InstanceConfig } from './internal-api/InstanceConfig.ts';
+import { RootNode } from '../client/RootNode.ts';
+import { InitializeFormOptions as BaseInitializeFormOptions, FormResource } from '../client/index.ts';
+import { InstanceConfig } from './internal-api/InstanceConfig.ts';
+
 interface InitializeFormOptions extends BaseInitializeFormOptions {
     readonly config: Partial<InstanceConfig>;
 }

package/dist/instance/internal-api/EvaluationContext.d.ts

@@ -1,7 +1,9 @@
-import type { XFormsXPathEvaluator } from '@getodk/xpath';
-import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
-import type { SubscribableDependency } from './SubscribableDependency.ts';
-import type { TranslationContext } from './TranslationContext.ts';
+import { XFormsXPathEvaluator } from '@getodk/xpath';
+import { Accessor } from 'solid-js';
+import { ReactiveScope } from '../../lib/reactivity/scope.ts';
+import { SubscribableDependency } from './SubscribableDependency.ts';
+import { TranslationContext } from './TranslationContext.ts';
+
 export interface EvaluationContextRoot extends SubscribableDependency, TranslationContext {
 }
 /**
@@ -24,11 +26,11 @@ export interface EvaluationContext {
      * Produces the current absolute reference to the {@link contextNode}, where
      * the absolute `/` resolves to the active form state's primary instance root.
      */
-    get contextReference(): string;
+    readonly contextReference: Accessor<string>;
     readonly contextNode: Node;
     /**
-     * Resolves a nodeset reference, possibly relative to the
-     * {@link EvaluationContext.contextNode}.
+     * Resolves nodes corresponding to the provided node-set reference, possibly
+     * relative to the {@link EvaluationContext.contextNode}.
      */
-    readonly getSubscribableDependencyByReference: (reference: string) => SubscribableDependency | null;
+    getSubscribableDependenciesByReference(reference: string): readonly SubscribableDependency[];
 }

package/dist/instance/internal-api/InstanceConfig.d.ts

@@ -1,5 +1,6 @@
-import type { EngineConfig } from '../../client/EngineConfig.ts';
-import type { CreateUniqueId } from '../../lib/unique-id.ts';
+import { EngineConfig } from '../../client/EngineConfig.ts';
+import { CreateUniqueId } from '../../lib/unique-id.ts';
+
 export interface InstanceConfig extends Required<EngineConfig> {
     /**
      * Uniqueness per form instance session (so e.g. persistence isn't necessary).

package/dist/instance/internal-api/SubscribableDependency.d.ts

@@ -1,4 +1,5 @@
-import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
+import { ReactiveScope } from '../../lib/reactivity/scope.ts';
+
 /**
  * Provides a common interface to explicitly establish a reactive subscription
  * to a form node, regardless of which node-specific details might trigger

package/dist/instance/internal-api/TranslationContext.d.ts

@@ -1,4 +1,5 @@
-import type { ActiveLanguage } from '../../index.ts';
+import { ActiveLanguage } from '../../index.ts';
+
 export interface TranslationContext {
     get activeLanguage(): ActiveLanguage;
 }

package/dist/instance/internal-api/ValueContext.d.ts

@@ -1,6 +1,7 @@
-import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
-import type { BindComputation } from '../../model/BindComputation.ts';
-import type { EvaluationContext } from './EvaluationContext.ts';
+import { ReactiveScope } from '../../lib/reactivity/scope.ts';
+import { BindComputation } from '../../model/BindComputation.ts';
+import { EvaluationContext } from './EvaluationContext.ts';
+
 export type InstanceValue = string;
 interface ValueContextDefinitionBind {
     readonly calculate: BindComputation<'calculate'> | null;
@@ -14,8 +15,8 @@ export interface ValueContext<RuntimeValue> extends EvaluationContext {
     readonly scope: ReactiveScope;
     readonly definition: ValueContextDefinition;
     readonly contextNode: Element;
-    get isReadonly(): boolean;
-    get isRelevant(): boolean;
+    isReadonly(): boolean;
+    isRelevant(): boolean;
     readonly encodeValue: (this: unknown, runtimeValue: RuntimeValue) => InstanceValue;
     readonly decodeValue: (this: unknown, instanceValue: InstanceValue) => RuntimeValue;
 }

package/dist/instance/resource.d.ts

@@ -1,5 +1,6 @@
-import type { FetchResource, FetchResourceResponse } from '../client/EngineConfig.ts';
-import type { FormResource } from '../client/index.ts';
+import { FetchResource, FetchResourceResponse } from '../client/EngineConfig.ts';
+import { FormResource } from '../client/index.ts';
+
 export type { FetchResource, FetchResourceResponse, FormResource };
 export interface ResourceOptions {
     readonly fetchResource: FetchResource;

package/dist/instance/text/TextChunk.d.ts

@@ -1,6 +1,7 @@
-import type { ActiveLanguage } from '../../client/FormLanguage.ts';
-import type { TextChunk as ClientTextChunk, TextChunkSource } from '../../client/TextRange.ts';
-import type { TranslationContext } from '../internal-api/TranslationContext.ts';
+import { ActiveLanguage } from '../../client/FormLanguage.ts';
+import { TextChunk as ClientTextChunk, TextChunkSource } from '../../client/TextRange.ts';
+import { TranslationContext } from '../internal-api/TranslationContext.ts';
+
 export declare class TextChunk implements ClientTextChunk {
     readonly context: TranslationContext;
     readonly source: TextChunkSource;

package/dist/instance/text/TextRange.d.ts

@@ -1,4 +1,5 @@
-import type { TextRange as ClientTextRange, TextChunk } from '../../client/TextRange.ts';
+import { TextRange as ClientTextRange, TextChunk } from '../../client/TextRange.ts';
+
 export type TextRole = 'hint' | 'label';
 export declare class TextRange<Role extends TextRole> implements ClientTextRange<Role> {
     readonly role: Role;

package/dist/lib/TokenListParser.d.ts

@@ -0,0 +1,84 @@
+import { PartiallyKnownString } from '../../../common/types/string/PartiallyKnownString.ts';
+
+type SymbolIterator = typeof Symbol.iterator;
+type TokenListKey<CanonicalToken extends string> = PartiallyKnownString<CanonicalToken> | SymbolIterator;
+type TokenListIterator<CanonicalToken extends string> = IterableIterator<PartiallyKnownString<CanonicalToken>>;
+/**
+ * @see {@link TokenListParser}
+ */
+export type TokenList<CanonicalToken extends string = string> = {
+    readonly [Key in TokenListKey<CanonicalToken>]: Key extends SymbolIterator ? () => TokenListIterator<CanonicalToken> : boolean;
+};
+interface TokenListAlias<CanonicalToken extends string> {
+    readonly fromAlias: string;
+    readonly toCanonical: CanonicalToken;
+}
+type TokenAliases<CanonicalToken extends string> = ReadonlyArray<TokenListAlias<CanonicalToken>>;
+interface TokenListParserOptions<CanonicalToken extends string> {
+    readonly aliases?: TokenAliases<CanonicalToken>;
+}
+type TokenListAttributeName = PartiallyKnownString<'appearance' | 'class'>;
+/**
+ * Intended primarily for use in parsing these features:
+ *
+ * - {@link https://getodk.github.io/xforms-spec/#appearances | appearances} ({@link https://xlsform.org/en/#appearance | additional documentation})
+ *
+ * - {@link https://getodk.github.io/xforms-spec/#body-attributes | body `class` attribute}
+ *
+ * This class is named as a reference to {@link DOMTokenList}
+ * ({@link https://developer.mozilla.org/en-US/docs/Web/API/DOMTokenList | MDN}),
+ * with these similarities:
+ *
+ * - Represents a value whose serialization is a space-separated list.
+ * - Each member ("token") is a string (without whitespace).
+ * - Provides set-like semantics to determine presence of members.
+ * - Provides ordering semantics as determined by the serialization.
+ *
+ * This class differs from that prior art in that:
+ *
+ * - It provides a notion of "canonical" members. This is _mostly_ (but not
+ *   entirely) intended as a convenience to client developers, automatically
+ *   populating canonical/known tokens for a given parser type in
+ *   editor-provided autocomplete, etc. **Importantly**, non-canonical tokens
+ *   _are not ignored_ in either the {@link TokenList}'s types or runtime
+ *   values.
+ *
+ * - Provided "canonical" members may also be used to specify
+ *   {@link TokenListParserOptions.aliases | optional aliases}. (Example: when
+ *   parsing "appearances", an alias might map an older deprecated appearance to
+ *   a newer canonical equivalent.) **Importantly**, when a token matches an
+ *   alias, both that alias _and the token as-specified_ will be present in the
+ *   produced {@link TokenList}.
+ *
+ * - As a parser, it is intended to be read-only. The serialized format which it
+ *   parses is _generally_ the source of truth (excepting e.g. aliases).
+ *   Notably, and as mentioned above, ordering is determined by:
+ *
+ *     - Iterating each member, as provided by the serialized representation
+ *
+ *     - If that member corresponds to an alias, that alias is yielded first
+ *
+ *     - Regardless of whether the member corresponds to an alias, the member is
+ *       yielded as-specified
+ *
+ * - A parsed {@link TokenList} is intended to maximize convenience of read-only
+ *   access. Despite many _conceptual similarities_, most of the
+ *   {@link DOMTokenList} **interface** is eschewed in favor of two (mutually
+ *   equivalent) access mechanisms:
+ *
+ *     - `Iterable<Token>`, with the ordering semantics described above
+ *     - `Record<Token, boolean>`
+ *
+ * \* This may change, as we refine requirements. In the future, we may
+ * introduce a notion of mutually exclusive tokens (e.g. "appearances" which
+ * cannot be used together), which may in turn utilize instance-defined ordering
+ * as part of that mechanism.
+ */
+export declare class TokenListParser<CanonicalToken extends string, TokenAlias extends CanonicalToken = CanonicalToken> {
+    readonly canonicalTokens: readonly CanonicalToken[];
+    private readonly aliases;
+    constructor(canonicalTokens: readonly CanonicalToken[], options?: TokenListParserOptions<TokenAlias>);
+    parseFrom(element: Element, attributeName: TokenListAttributeName): TokenList<CanonicalToken>;
+}
+export type ParsedTokenList<Parser extends TokenListParser<any>> = Parser extends TokenListParser<infer CanonicalToken> ? TokenList<CanonicalToken> : never;
+export {};

package/dist/lib/dom/query.d.ts

@@ -1,5 +1,6 @@
-import type { KnownAttributeLocalNamedElement, LocalNamedElement } from '../../../../common/types/dom.ts';
-import type { SelectElement } from '../../body/control/select/SelectDefinition';
+import { KnownAttributeLocalNamedElement, LocalNamedElement } from '../../../../common/types/dom.ts';
+import { SelectElement } from '../../body/control/select/SelectDefinition';
+
 export interface HintElement extends LocalNamedElement<'hint'> {
 }
 export interface ItemElement extends LocalNamedElement<'item'> {
@@ -8,6 +9,10 @@ export interface ItemsetElement extends KnownAttributeLocalNamedElement<'itemset
 }
 export interface LabelElement extends LocalNamedElement<'label'> {
 }
+export interface RepeatGroupLabelElement extends LabelElement {
+    getAttribute(name: 'form-definition-source'): 'repeat-group';
+    getAttribute(name: string): string;
+}
 export interface RepeatElement extends KnownAttributeLocalNamedElement<'repeat', 'nodeset'> {
 }
 export interface ValueElement extends LocalNamedElement<'value'> {
@@ -16,5 +21,6 @@ export declare const getHintElement: (parent: Element) => HintElement | null;
 export declare const getItemElements: (parent: SelectElement) => readonly ItemElement[];
 export declare const getItemsetElement: (parent: Element) => ItemsetElement | null;
 export declare const getLabelElement: (parent: Element) => LabelElement | null;
+export declare const getRepeatGroupLabelElement: (parent: Element) => RepeatGroupLabelElement | null;
 export declare const getRepeatElement: (parent: Element) => RepeatElement | null;
 export declare const getValueElement: (parent: ItemElement | ItemsetElement) => ValueElement | null;

package/dist/lib/reactivity/createChildrenState.d.ts

@@ -1,6 +1,7 @@
-import { type Accessor, type Setter, type Signal } from 'solid-js';
-import type { AnyChildNode, AnyParentNode } from '../../instance/hierarchy.ts';
-import type { NodeID } from '../../instance/identity.ts';
+import { Accessor, Setter, Signal } from 'solid-js';
+import { AnyChildNode, AnyParentNode } from '../../instance/hierarchy.ts';
+import { NodeID } from '../../instance/identity.ts';
+
 export interface ChildrenState<Child extends AnyChildNode> {
     readonly children: Signal<readonly Child[]>;
     readonly getChildren: Accessor<readonly Child[]>;

package/dist/lib/reactivity/createComputedExpression.d.ts

@@ -1,6 +1,7 @@
-import type { Accessor } from 'solid-js';
-import type { DependentExpression, DependentExpressionResultType } from '../../expression/DependentExpression.ts';
-import type { EvaluationContext } from '../../instance/internal-api/EvaluationContext.ts';
+import { Accessor } from 'solid-js';
+import { DependentExpression, DependentExpressionResultType } from '../../expression/DependentExpression.ts';
+import { EvaluationContext } from '../../instance/internal-api/EvaluationContext.ts';
+
 interface ComputedExpressionResults {
     readonly boolean: boolean;
     readonly nodes: Node[];

package/dist/lib/reactivity/createSelectItems.d.ts

@@ -1,6 +1,7 @@
-import type { Accessor } from 'solid-js';
-import type { SelectItem } from '../../index.ts';
-import type { SelectField } from '../../instance/SelectField.ts';
+import { Accessor } from 'solid-js';
+import { SelectItem } from '../../index.ts';
+import { SelectField } from '../../instance/SelectField.ts';
+
 /**
  * Creates a reactive computation of a {@link SelectField}'s
  * {@link SelectItem}s, in support of the field's `valueOptions`.

package/dist/lib/reactivity/createValueState.d.ts

@@ -1,5 +1,6 @@
-import type { ValueContext } from '../../instance/internal-api/ValueContext.ts';
-import type { SimpleAtomicState } from './types.ts';
+import { ValueContext } from '../../instance/internal-api/ValueContext.ts';
+import { SimpleAtomicState } from './types.ts';
+
 type InitialValueSource = 'FORM_DEFAULT' | 'PRIMARY_INSTANCE';
 export interface ValueStateOptions {
     /**

package/dist/lib/reactivity/materializeCurrentStateChildren.d.ts

@@ -1,6 +1,8 @@
-import type { AnyChildNode } from '../../instance/hierarchy.ts';
-import type { NodeID } from '../../instance/identity.ts';
-import type { ChildrenState } from './createChildrenState.ts';
+import { AnyChildNode } from '../../instance/hierarchy.ts';
+import { NodeID } from '../../instance/identity.ts';
+import { ChildrenState } from './createChildrenState.ts';
+import { ReactiveScope } from './scope.ts';
+
 export interface EncodedParentState {
     readonly children: readonly NodeID[];
 }
@@ -15,4 +17,4 @@ export type MaterializedChildren<BaseState extends EncodedParentState, Child ext
  *
  * @see {@link createChildrenState} for further detail.
  */
-export declare const materializeCurrentStateChildren: <Child extends AnyChildNode, ParentState extends EncodedParentState>(currentState: ParentState, childrenState: ChildrenState<Child>) => MaterializedChildren<ParentState, Child>;
+export declare const materializeCurrentStateChildren: <Child extends AnyChildNode, ParentState extends EncodedParentState>(scope: ReactiveScope, currentState: ParentState, childrenState: ChildrenState<Child>) => MaterializedChildren<ParentState, Child>;

package/dist/lib/reactivity/node-state/createClientState.d.ts

@@ -1,9 +1,10 @@
-import type { ShallowMutable } from '../../../../../common/types/helpers.js';
-import type { OpaqueReactiveObjectFactory } from '../../../index.ts';
-import type { ReactiveScope } from '../scope.ts';
-import type { EngineState } from './createEngineState.ts';
-import type { SpecifiedState, StateSpec } from './createSpecifiedState.ts';
-import type { InternalClientRepresentation } from './representations.ts';
+import { ShallowMutable } from '../../../../../common/types/helpers.js';
+import { OpaqueReactiveObjectFactory } from '../../../index.ts';
+import { ReactiveScope } from '../scope.ts';
+import { EngineState } from './createEngineState.ts';
+import { SpecifiedState, StateSpec } from './createSpecifiedState.ts';
+import { InternalClientRepresentation } from './representations.ts';
+
 export type SpecifiedClientStateFactory<Factory extends OpaqueReactiveObjectFactory, Spec extends StateSpec> = ShallowMutable<SpecifiedState<Spec>> extends Parameters<Factory>[0] ? Factory : never;
 export type ClientState<Spec extends StateSpec> = InternalClientRepresentation<SpecifiedState<Spec>>;
 export declare const createClientState: <Factory extends OpaqueReactiveObjectFactory, Spec extends StateSpec>(scope: ReactiveScope, engineState: EngineState<Spec>, clientStateFactory: SpecifiedClientStateFactory<Factory, Spec>) => ClientState<Spec>;

package/dist/lib/reactivity/node-state/createCurrentState.d.ts

@@ -1,6 +1,7 @@
-import type { ReactiveScope } from '../scope.ts';
-import type { ClientState } from './createClientState.ts';
-import type { SpecifiedState, StateSpec } from './createSpecifiedState.ts';
-import type { ReadonlyClientRepresentation } from './representations.ts';
+import { ReactiveScope } from '../scope.ts';
+import { ClientState } from './createClientState.ts';
+import { SpecifiedState, StateSpec } from './createSpecifiedState.ts';
+import { ReadonlyClientRepresentation } from './representations.ts';
+
 export type CurrentState<Spec extends StateSpec> = ReadonlyClientRepresentation<SpecifiedState<Spec>>;
 export declare const createCurrentState: <Spec extends StateSpec>(scope: ReactiveScope, clientState: ClientState<Spec>) => CurrentState<Spec>;

package/dist/lib/reactivity/node-state/createEngineState.d.ts

@@ -1,5 +1,6 @@
-import type { ReactiveScope } from '../scope.ts';
-import type { SpecifiedState, StateSpec } from './createSpecifiedState.ts';
-import type { EngineRepresentation } from './representations.ts';
+import { ReactiveScope } from '../scope.ts';
+import { SpecifiedState, StateSpec } from './createSpecifiedState.ts';
+import { EngineRepresentation } from './representations.ts';
+
 export type EngineState<Spec extends StateSpec> = EngineRepresentation<SpecifiedState<Spec>>;
 export declare const createEngineState: <Spec extends StateSpec>(scope: ReactiveScope, spec: Spec) => EngineState<Spec>;

package/dist/lib/reactivity/node-state/createSharedNodeState.d.ts

@@ -1,9 +1,10 @@
-import type { OpaqueReactiveObjectFactory } from '../../../index.ts';
-import type { ReactiveScope } from '../scope.ts';
-import type { ClientState, SpecifiedClientStateFactory } from './createClientState.ts';
-import type { CurrentState } from './createCurrentState.ts';
-import type { EngineState } from './createEngineState.ts';
-import type { MutablePropertySpec, SpecifiedState, StateSpec } from './createSpecifiedState.ts';
+import { OpaqueReactiveObjectFactory } from '../../../index.ts';
+import { ReactiveScope } from '../scope.ts';
+import { ClientState, SpecifiedClientStateFactory } from './createClientState.ts';
+import { CurrentState } from './createCurrentState.ts';
+import { EngineState } from './createEngineState.ts';
+import { MutablePropertySpec, SpecifiedState, StateSpec } from './createSpecifiedState.ts';
+
 type MutableKeyOf<Spec extends StateSpec> = {
     [K in string & keyof Spec]: Spec[K] extends MutablePropertySpec<any> ? K : never;
 }[string & keyof Spec];

package/dist/lib/reactivity/node-state/createSpecifiedPropertyDescriptor.d.ts

@@ -1,4 +1,5 @@
-import type { StatePropertySpec } from './createSpecifiedState.ts';
+import { StatePropertySpec } from './createSpecifiedState.ts';
+
 export interface SpecifiedPropertyDescriptor<T = any> extends TypedPropertyDescriptor<T> {
     readonly configurable: true;
     readonly enumerable: true;

package/dist/lib/reactivity/node-state/createSpecifiedState.d.ts

@@ -1,5 +1,6 @@
-import type { Accessor, Signal } from 'solid-js';
-import type { SimpleAtomicState } from '../types.ts';
+import { Accessor, Signal } from 'solid-js';
+import { SimpleAtomicState } from '../types.ts';
+
 /**
  * Specifies a state object's property as mutable. Basic usage:
  *

package/dist/lib/reactivity/node-state/representations.d.ts

@@ -1,4 +1,5 @@
-import type { ShallowMutable } from '../../../../../common/types/helpers.js';
+import { ShallowMutable } from '../../../../../common/types/helpers.js';
+
 declare const ENGINE_REPRESENTATION: unique symbol;
 type ENGINE_REPRESENTATION = typeof ENGINE_REPRESENTATION;
 declare const INTERNAL_CLIENT_REPRESENTATION: unique symbol;

package/dist/lib/reactivity/scope.d.ts

@@ -1,4 +1,5 @@
-import type { Owner } from 'solid-js';
+import { Owner } from 'solid-js';
+
 type ReactiveScopeTask<T> = (scope: ReactiveScope) => T;
 type RunReactiveScopeTask = <T>(task: ReactiveScopeTask<T>) => T;
 export interface ReactiveScope {

package/dist/lib/reactivity/text/createFieldHint.d.ts

@@ -1,5 +1,6 @@
-import { type Accessor } from 'solid-js';
-import type { EvaluationContext } from '../../../instance/internal-api/EvaluationContext.ts';
+import { Accessor } from 'solid-js';
+import { EvaluationContext } from '../../../instance/internal-api/EvaluationContext.ts';
 import { TextRange } from '../../../instance/text/TextRange.ts';
-import type { ValueNodeDefinition } from '../../../model/ValueNodeDefinition.ts';
+import { ValueNodeDefinition } from '../../../model/ValueNodeDefinition.ts';
+
 export declare const createFieldHint: (context: EvaluationContext, definition: ValueNodeDefinition) => Accessor<TextRange<'hint'> | null>;

package/dist/lib/reactivity/text/createNodeLabel.d.ts

@@ -1,5 +1,6 @@
-import { type Accessor } from 'solid-js';
-import type { EvaluationContext } from '../../../instance/internal-api/EvaluationContext.ts';
+import { Accessor } from 'solid-js';
+import { EvaluationContext } from '../../../instance/internal-api/EvaluationContext.ts';
 import { TextRange } from '../../../instance/text/TextRange.ts';
-import type { AnyNodeDefinition } from '../../../model/NodeDefinition.ts';
+import { AnyNodeDefinition } from '../../../model/NodeDefinition.ts';
+
 export declare const createNodeLabel: (context: EvaluationContext, definition: AnyNodeDefinition) => Accessor<TextRange<'label'> | null>;

package/dist/lib/reactivity/text/createTextRange.d.ts

@@ -1,7 +1,8 @@
-import { type Accessor } from 'solid-js';
-import type { TextElementDefinition } from '../../../body/text/TextElementDefinition.ts';
-import type { EvaluationContext } from '../../../instance/internal-api/EvaluationContext.ts';
-import { TextRange, type TextRole } from '../../../instance/text/TextRange.ts';
+import { Accessor } from 'solid-js';
+import { TextElementDefinition } from '../../../body/text/TextElementDefinition.ts';
+import { EvaluationContext } from '../../../instance/internal-api/EvaluationContext.ts';
+import { TextRange, TextRole } from '../../../instance/text/TextRange.ts';
+
 interface CreateTextRangeOptions<FallbackValue extends string | null> {
     readonly fallbackValue?: FallbackValue;
 }
@@ -15,5 +16,5 @@ type ComputedTextRange<Role extends TextRole, Definition extends TextElementDefi
  *
  * @todo This does not yet handle itext translations **with** outputs!
  */
-export declare const createTextRange: <Role extends TextRole, Definition extends TextElementDefinition<Role> | null, FallbackValue extends string | null = null>(context: EvaluationContext, role: Role, definition: Definition, options?: CreateTextRangeOptions<FallbackValue> | undefined) => ComputedTextRange<Role, Definition, FallbackValue>;
+export declare const createTextRange: <Role extends TextRole, Definition extends TextElementDefinition<Role> | null, FallbackValue extends string | null = null>(context: EvaluationContext, role: Role, definition: Definition, options?: CreateTextRangeOptions<FallbackValue>) => ComputedTextRange<Role, Definition, FallbackValue>;
 export {};

package/dist/lib/reactivity/types.d.ts

@@ -1,4 +1,5 @@
-import type { Accessor, Setter } from 'solid-js';
+import { Accessor, Setter } from 'solid-js';
+
 /**
  * A write interface to reactive atomic state. This type is intended to be used
  * as a relaxed version of {@link Setter}, where its callback form isn't