@orkestrel/reason 0.0.4 → 0.0.6

package/dist/src/core/index.d.cts

@@ -1844,9 +1844,9 @@ export declare interface AggregatorOptions {
         * findDuplicates([{ id: 'a' }, { id: 'b' }, { id: 'a' }, { id: 'a' }]) // ['a']
         * ```
         */
-       export declare function findDuplicates(items: readonly {
+       export declare function findDuplicates(items: ReadonlyArray<{
            readonly id: string;
-       }[]): readonly string[];
+       }>): readonly string[];
 
        /**
         * The `formatField`-flattened overlay keys an array-path conclusion atom
@@ -2427,6 +2427,22 @@ export declare interface AggregatorOptions {
         */
        export declare function isCheck(value: unknown): value is Check;
 
+       /**
+        * Determine whether a value is a {@link CheckResult}.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published check-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isCheckResult } from '@src/core'
+        *
+        * isCheckResult({ field: 'age', met: true, actual: 30 }) // true
+        * isCheckResult({ field: 'age', met: 'yes', actual: 30 }) // false
+        * ```
+        */
+       export declare function isCheckResult(value: unknown): value is CheckResult;
+
        /**
         * Determine whether a value is a {@link Comparison} literal.
         *
@@ -2602,6 +2618,22 @@ export declare interface AggregatorOptions {
         */
        export declare function isFactorRange(value: unknown): value is FactorRange;
 
+       /**
+        * Determine whether a value is a {@link FactorResult}.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published factor-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isFactorResult } from '@src/core'
+        *
+        * isFactorResult({ id: 'age', applied: true, value: 5 }) // true
+        * isFactorResult({ id: 'age', applied: true, value: '5' }) // false
+        * ```
+        */
+       export declare function isFactorResult(value: unknown): value is FactorResult;
+
        /**
         * Determine whether a value is a {@link FieldPath} — a single string key or an
         * array of keys descending into nested objects.
@@ -2620,6 +2652,22 @@ export declare interface AggregatorOptions {
         */
        export declare const isFieldPath: Guard<FieldPath>;
 
+       /**
+        * Determine whether a value is a {@link GroupResult}.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published group-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isGroupResult } from '@src/core'
+        *
+        * isGroupResult({ id: 'risk', applied: true, value: 5, factors: [] }) // true
+        * isGroupResult({ id: 'risk', applied: true, value: 5 }) // false
+        * ```
+        */
+       export declare function isGroupResult(value: unknown): value is GroupResult;
+
        /**
         * Determine whether a value is an {@link Inference} — premise patterns and a
         * conclusion pattern.
@@ -2653,6 +2701,22 @@ export declare interface AggregatorOptions {
         */
        export declare function isInferentialDefinition(value: unknown): value is InferentialDefinition;
 
+       /**
+        * Determine whether a value is an {@link InferentialResult}.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published inferential-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isInferentialResult } from '@src/core'
+        *
+        * isInferentialResult({ reasoning: 'inferential', derived: [], success: true, trace: [], errors: [] }) // true
+        * isInferentialResult({ reasoning: 'inferential', derived: [null], success: true, trace: [], errors: [] }) // false
+        * ```
+        */
+       export declare function isInferentialResult(value: unknown): value is InferentialResult;
+
        /**
         * Determine whether a value is a {@link LogicalDefinition}.
         *
@@ -2685,6 +2749,22 @@ export declare interface AggregatorOptions {
         */
        export declare const isLogicalOperator: Guard<LogicalOperator>;
 
+       /**
+        * Determine whether a value is a {@link LogicalResult}.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published logical-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isLogicalResult } from '@src/core'
+        *
+        * isLogicalResult({ reasoning: 'logical', conclusion: false, rules: [], count: 0, success: true, trace: [], errors: [] }) // true
+        * isLogicalResult({ reasoning: 'logical', rules: [] }) // false
+        * ```
+        */
+       export declare function isLogicalResult(value: unknown): value is LogicalResult;
+
        /**
         * Determine whether a value is a {@link MathOperation} literal.
         *
@@ -2718,6 +2798,30 @@ export declare interface AggregatorOptions {
         */
        export declare const isNumberRecord: Guard<Readonly<Record<string, number>>>;
 
+       /**
+        * Determine whether a value is a depth-bounded, acyclic {@link ProofNode} tree.
+        *
+        * @remarks
+        * Traversal is iterative and reuses `GUARD_DEPTH_LIMIT`. Active ancestors refuse cycles, and a
+        * settled-depth record prevents repeated validation of shared subtrees while keeping the bound
+        * exact: a node revisited no deeper than its validated depth is skipped, and one reached deeper
+        * is walked again. The traversal accepts an acyclic graph only when every reachable node is
+        * valid and every root-to-node path contains at most `GUARD_DEPTH_LIMIT` nodes; shared aliases
+        * and sibling order do not affect the verdict.
+        *
+        * @param value - The value to test
+        * @returns `true` when every proof node is valid within the runtime guard bound
+        *
+        * @example
+        * ```ts
+        * import { isProofNode } from '@src/core'
+        *
+        * isProofNode({ fact: 'bird', depth: 0, children: [{ fact: 'feathers', depth: 1 }] }) // true
+        * isProofNode({ fact: 'bird', children: [] }) // false
+        * ```
+        */
+       export declare function isProofNode(value: unknown): value is ProofNode;
+
        /**
         * Determine whether a value is a {@link QuantitativeDefinition}.
         *
@@ -2734,6 +2838,22 @@ export declare interface AggregatorOptions {
         */
        export declare function isQuantitativeDefinition(value: unknown): value is QuantitativeDefinition;
 
+       /**
+        * Determine whether a value is a {@link QuantitativeResult}.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published quantitative-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isQuantitativeResult } from '@src/core'
+        *
+        * isQuantitativeResult({ reasoning: 'quantitative', value: 0, groups: [], count: 0, success: true, trace: [], errors: [] }) // true
+        * isQuantitativeResult({ reasoning: 'quantitative' }) // false
+        * ```
+        */
+       export declare function isQuantitativeResult(value: unknown): value is QuantitativeResult;
+
        /**
         * Narrow an unknown caught value to a {@link ReasonError}.
         *
@@ -2767,6 +2887,58 @@ export declare interface AggregatorOptions {
         */
        export declare const isReasoning: Guard<Reasoning>;
 
+       /**
+        * Determine whether a value is any {@link ReasonResult} arm.
+        *
+        * @param value - The value to test
+        * @returns `true` when one complete reasoning-result guard accepts the value
+        *
+        * @example
+        * ```ts
+        * import { isReasonResult } from '@src/core'
+        *
+        * isReasonResult({ reasoning: 'symbolic', solutions: {}, success: true, trace: [], errors: [] }) // true
+        * isReasonResult({ reasoning: 'unknown' }) // false
+        * ```
+        */
+       export declare function isReasonResult(value: unknown): value is ReasonResult;
+
+       /**
+        * Determine whether a value is a {@link ReasonValidationResult}.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published validation-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isReasonValidationResult } from '@src/core'
+        *
+        * isReasonValidationResult({ valid: true, errors: [], warnings: [] }) // true
+        * isReasonValidationResult({ valid: true, errors: [] }) // false
+        * ```
+        */
+       export declare function isReasonValidationResult(value: unknown): value is ReasonValidationResult;
+
+       /**
+        * Determine whether a value is a result-side {@link Fact}.
+        *
+        * @remarks
+        * Unlike the exact input guard {@link isFact}, this guard accepts unknown
+        * members, class instances, and every JavaScript `number` confidence.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published fact member is valid for a result
+        *
+        * @example
+        * ```ts
+        * import { isResultFact } from '@src/core'
+        *
+        * isResultFact({ id: 'f1', predicate: 'bird', terms: ['tweety'], note: 'derived' }) // true
+        * isResultFact({ id: 'f1', predicate: 'bird' }) // false
+        * ```
+        */
+       export declare function isResultFact(value: unknown): value is Fact;
+
        /**
         * Determine whether a value is a {@link Rule} — premises and a conclusion.
         *
@@ -2783,6 +2955,22 @@ export declare interface AggregatorOptions {
         */
        export declare function isRule(value: unknown): value is Rule;
 
+       /**
+        * Determine whether a value is a {@link RuleResult}.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published rule-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isRuleResult } from '@src/core'
+        *
+        * isRuleResult({ id: 'adult', applied: true, premises: [true], conclusion: true }) // true
+        * isRuleResult({ id: 'adult', applied: true, premises: [1], conclusion: true }) // false
+        * ```
+        */
+       export declare function isRuleResult(value: unknown): value is RuleResult;
+
        /**
         * Determine whether a value is a {@link Source} — any of the four factor
         * sources, discriminated by `origin`.
@@ -2883,6 +3071,27 @@ export declare interface AggregatorOptions {
         */
        export declare function isSymbolicExpression(value: unknown): value is SymbolicExpression;
 
+       /**
+        * Determine whether a value is a {@link SymbolicResult}.
+        *
+        * @remarks
+        * `solutions` is checked across its OWN string-named members, enumerable or
+        * not. Inherited members are deliberately unread: they belong to the
+        * accepted-prototype property, not to the record this guard certifies.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published symbolic-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isSymbolicResult } from '@src/core'
+        *
+        * isSymbolicResult({ reasoning: 'symbolic', solutions: { x: 4 }, success: true, trace: [], errors: [] }) // true
+        * isSymbolicResult({ reasoning: 'symbolic', solutions: { x: '4' }, success: true, trace: [], errors: [] }) // false
+        * ```
+        */
+       export declare function isSymbolicResult(value: unknown): value is SymbolicResult;
+
        /**
         * Determine whether a value is a {@link Transform} — one math step.
         *
@@ -4720,13 +4929,14 @@ export declare interface AggregatorOptions {
                * a strict left fold — `NaN` flows through untouched. Stateless and
                * deterministic.
                */
-              export declare class Transformer implements TransformerInterface {
+              declare class Transformer_2 implements TransformerInterface {
                   #private;
                   constructor(options?: TransformerOptions);
                   get id(): string;
                   apply(value: number, transform: Transform): number;
                   chain(value: number, transforms: readonly Transform[]): number;
               }
+              export { Transformer_2 as Transformer }
 
               /** Default `id` for a `Transformer`. */
               export declare const TRANSFORMER_ID = "transformer";

package/dist/src/core/index.d.ts

@@ -1844,9 +1844,9 @@ export declare interface AggregatorOptions {
         * findDuplicates([{ id: 'a' }, { id: 'b' }, { id: 'a' }, { id: 'a' }]) // ['a']
         * ```
         */
-       export declare function findDuplicates(items: readonly {
+       export declare function findDuplicates(items: ReadonlyArray<{
            readonly id: string;
-       }[]): readonly string[];
+       }>): readonly string[];
 
        /**
         * The `formatField`-flattened overlay keys an array-path conclusion atom
@@ -2427,6 +2427,22 @@ export declare interface AggregatorOptions {
         */
        export declare function isCheck(value: unknown): value is Check;
 
+       /**
+        * Determine whether a value is a {@link CheckResult}.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published check-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isCheckResult } from '@src/core'
+        *
+        * isCheckResult({ field: 'age', met: true, actual: 30 }) // true
+        * isCheckResult({ field: 'age', met: 'yes', actual: 30 }) // false
+        * ```
+        */
+       export declare function isCheckResult(value: unknown): value is CheckResult;
+
        /**
         * Determine whether a value is a {@link Comparison} literal.
         *
@@ -2602,6 +2618,22 @@ export declare interface AggregatorOptions {
         */
        export declare function isFactorRange(value: unknown): value is FactorRange;
 
+       /**
+        * Determine whether a value is a {@link FactorResult}.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published factor-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isFactorResult } from '@src/core'
+        *
+        * isFactorResult({ id: 'age', applied: true, value: 5 }) // true
+        * isFactorResult({ id: 'age', applied: true, value: '5' }) // false
+        * ```
+        */
+       export declare function isFactorResult(value: unknown): value is FactorResult;
+
        /**
         * Determine whether a value is a {@link FieldPath} — a single string key or an
         * array of keys descending into nested objects.
@@ -2620,6 +2652,22 @@ export declare interface AggregatorOptions {
         */
        export declare const isFieldPath: Guard<FieldPath>;
 
+       /**
+        * Determine whether a value is a {@link GroupResult}.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published group-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isGroupResult } from '@src/core'
+        *
+        * isGroupResult({ id: 'risk', applied: true, value: 5, factors: [] }) // true
+        * isGroupResult({ id: 'risk', applied: true, value: 5 }) // false
+        * ```
+        */
+       export declare function isGroupResult(value: unknown): value is GroupResult;
+
        /**
         * Determine whether a value is an {@link Inference} — premise patterns and a
         * conclusion pattern.
@@ -2653,6 +2701,22 @@ export declare interface AggregatorOptions {
         */
        export declare function isInferentialDefinition(value: unknown): value is InferentialDefinition;
 
+       /**
+        * Determine whether a value is an {@link InferentialResult}.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published inferential-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isInferentialResult } from '@src/core'
+        *
+        * isInferentialResult({ reasoning: 'inferential', derived: [], success: true, trace: [], errors: [] }) // true
+        * isInferentialResult({ reasoning: 'inferential', derived: [null], success: true, trace: [], errors: [] }) // false
+        * ```
+        */
+       export declare function isInferentialResult(value: unknown): value is InferentialResult;
+
        /**
         * Determine whether a value is a {@link LogicalDefinition}.
         *
@@ -2685,6 +2749,22 @@ export declare interface AggregatorOptions {
         */
        export declare const isLogicalOperator: Guard<LogicalOperator>;
 
+       /**
+        * Determine whether a value is a {@link LogicalResult}.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published logical-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isLogicalResult } from '@src/core'
+        *
+        * isLogicalResult({ reasoning: 'logical', conclusion: false, rules: [], count: 0, success: true, trace: [], errors: [] }) // true
+        * isLogicalResult({ reasoning: 'logical', rules: [] }) // false
+        * ```
+        */
+       export declare function isLogicalResult(value: unknown): value is LogicalResult;
+
        /**
         * Determine whether a value is a {@link MathOperation} literal.
         *
@@ -2718,6 +2798,30 @@ export declare interface AggregatorOptions {
         */
        export declare const isNumberRecord: Guard<Readonly<Record<string, number>>>;
 
+       /**
+        * Determine whether a value is a depth-bounded, acyclic {@link ProofNode} tree.
+        *
+        * @remarks
+        * Traversal is iterative and reuses `GUARD_DEPTH_LIMIT`. Active ancestors refuse cycles, and a
+        * settled-depth record prevents repeated validation of shared subtrees while keeping the bound
+        * exact: a node revisited no deeper than its validated depth is skipped, and one reached deeper
+        * is walked again. The traversal accepts an acyclic graph only when every reachable node is
+        * valid and every root-to-node path contains at most `GUARD_DEPTH_LIMIT` nodes; shared aliases
+        * and sibling order do not affect the verdict.
+        *
+        * @param value - The value to test
+        * @returns `true` when every proof node is valid within the runtime guard bound
+        *
+        * @example
+        * ```ts
+        * import { isProofNode } from '@src/core'
+        *
+        * isProofNode({ fact: 'bird', depth: 0, children: [{ fact: 'feathers', depth: 1 }] }) // true
+        * isProofNode({ fact: 'bird', children: [] }) // false
+        * ```
+        */
+       export declare function isProofNode(value: unknown): value is ProofNode;
+
        /**
         * Determine whether a value is a {@link QuantitativeDefinition}.
         *
@@ -2734,6 +2838,22 @@ export declare interface AggregatorOptions {
         */
        export declare function isQuantitativeDefinition(value: unknown): value is QuantitativeDefinition;
 
+       /**
+        * Determine whether a value is a {@link QuantitativeResult}.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published quantitative-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isQuantitativeResult } from '@src/core'
+        *
+        * isQuantitativeResult({ reasoning: 'quantitative', value: 0, groups: [], count: 0, success: true, trace: [], errors: [] }) // true
+        * isQuantitativeResult({ reasoning: 'quantitative' }) // false
+        * ```
+        */
+       export declare function isQuantitativeResult(value: unknown): value is QuantitativeResult;
+
        /**
         * Narrow an unknown caught value to a {@link ReasonError}.
         *
@@ -2767,6 +2887,58 @@ export declare interface AggregatorOptions {
         */
        export declare const isReasoning: Guard<Reasoning>;
 
+       /**
+        * Determine whether a value is any {@link ReasonResult} arm.
+        *
+        * @param value - The value to test
+        * @returns `true` when one complete reasoning-result guard accepts the value
+        *
+        * @example
+        * ```ts
+        * import { isReasonResult } from '@src/core'
+        *
+        * isReasonResult({ reasoning: 'symbolic', solutions: {}, success: true, trace: [], errors: [] }) // true
+        * isReasonResult({ reasoning: 'unknown' }) // false
+        * ```
+        */
+       export declare function isReasonResult(value: unknown): value is ReasonResult;
+
+       /**
+        * Determine whether a value is a {@link ReasonValidationResult}.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published validation-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isReasonValidationResult } from '@src/core'
+        *
+        * isReasonValidationResult({ valid: true, errors: [], warnings: [] }) // true
+        * isReasonValidationResult({ valid: true, errors: [] }) // false
+        * ```
+        */
+       export declare function isReasonValidationResult(value: unknown): value is ReasonValidationResult;
+
+       /**
+        * Determine whether a value is a result-side {@link Fact}.
+        *
+        * @remarks
+        * Unlike the exact input guard {@link isFact}, this guard accepts unknown
+        * members, class instances, and every JavaScript `number` confidence.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published fact member is valid for a result
+        *
+        * @example
+        * ```ts
+        * import { isResultFact } from '@src/core'
+        *
+        * isResultFact({ id: 'f1', predicate: 'bird', terms: ['tweety'], note: 'derived' }) // true
+        * isResultFact({ id: 'f1', predicate: 'bird' }) // false
+        * ```
+        */
+       export declare function isResultFact(value: unknown): value is Fact;
+
        /**
         * Determine whether a value is a {@link Rule} — premises and a conclusion.
         *
@@ -2783,6 +2955,22 @@ export declare interface AggregatorOptions {
         */
        export declare function isRule(value: unknown): value is Rule;
 
+       /**
+        * Determine whether a value is a {@link RuleResult}.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published rule-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isRuleResult } from '@src/core'
+        *
+        * isRuleResult({ id: 'adult', applied: true, premises: [true], conclusion: true }) // true
+        * isRuleResult({ id: 'adult', applied: true, premises: [1], conclusion: true }) // false
+        * ```
+        */
+       export declare function isRuleResult(value: unknown): value is RuleResult;
+
        /**
         * Determine whether a value is a {@link Source} — any of the four factor
         * sources, discriminated by `origin`.
@@ -2883,6 +3071,27 @@ export declare interface AggregatorOptions {
         */
        export declare function isSymbolicExpression(value: unknown): value is SymbolicExpression;
 
+       /**
+        * Determine whether a value is a {@link SymbolicResult}.
+        *
+        * @remarks
+        * `solutions` is checked across its OWN string-named members, enumerable or
+        * not. Inherited members are deliberately unread: they belong to the
+        * accepted-prototype property, not to the record this guard certifies.
+        *
+        * @param value - The value to test
+        * @returns `true` when every published symbolic-result member is valid
+        *
+        * @example
+        * ```ts
+        * import { isSymbolicResult } from '@src/core'
+        *
+        * isSymbolicResult({ reasoning: 'symbolic', solutions: { x: 4 }, success: true, trace: [], errors: [] }) // true
+        * isSymbolicResult({ reasoning: 'symbolic', solutions: { x: '4' }, success: true, trace: [], errors: [] }) // false
+        * ```
+        */
+       export declare function isSymbolicResult(value: unknown): value is SymbolicResult;
+
        /**
         * Determine whether a value is a {@link Transform} — one math step.
         *
@@ -4720,13 +4929,14 @@ export declare interface AggregatorOptions {
                * a strict left fold — `NaN` flows through untouched. Stateless and
                * deterministic.
                */
-              export declare class Transformer implements TransformerInterface {
+              declare class Transformer_2 implements TransformerInterface {
                   #private;
                   constructor(options?: TransformerOptions);
                   get id(): string;
                   apply(value: number, transform: Transform): number;
                   chain(value: number, transforms: readonly Transform[]): number;
               }
+              export { Transformer_2 as Transformer }
 
               /** Default `id` for a `Transformer`. */
               export declare const TRANSFORMER_ID = "transformer";