From 1cfa1f6a49d1f2e3e512a74ab611c82c5c2db773 Mon Sep 17 00:00:00 2001
From: Paul Visscher <p.e.visscher@skyleague.io>
Date: Sun, 19 May 2024 22:44:53 +0200
Subject: [PATCH] refactor: remove tree type inferrence

---
 src/engine/operator.ts                  | 27 ++++++------
 src/engine/policy.ts                    | 24 ++++-------
 src/engine/types.spec.ts                |  4 +-
 src/engine/types.ts                     | 17 +++++---
 src/expressions/boolean.spec.ts         | 57 ++++++++++++++++++-------
 src/expressions/boolean.ts              | 10 ++---
 src/expressions/higher-order-fn.spec.ts | 24 +++++++----
 src/expressions/higher-order-fn.ts      | 19 +++++++--
 src/expressions/input.ts                | 26 +++++------
 src/expressions/logic.spec.ts           | 28 +++++++++---
 src/expressions/logic.ts                |  4 +-
 src/expressions/number-array.spec.ts    | 20 ++++++---
 src/expressions/number.spec.ts          | 42 +++++++++++-------
 src/expressions/string.spec.ts          | 11 +++--
 test/policies.spec.ts                   |  5 ++-
 15 files changed, 198 insertions(+), 120 deletions(-)

diff --git a/src/engine/operator.ts b/src/engine/operator.ts
index bcfd72a..11a091a 100644
--- a/src/engine/operator.ts
+++ b/src/engine/operator.ts
@@ -1,9 +1,9 @@
+import { inspect } from 'node:util'
+import type { JSONExpr } from '../json/jsonexpr.type.js'
 import type { AsExpression, DefinitionType, Expression, ValueExpression } from './types.js'
 import { fromLiteral } from './types.js'
 
-import type { JSONExpr } from '../json/jsonexpr.type.js'
-
-import { inspect } from 'node:util'
+export type FactsFomExprs<T> = T extends { facts: infer U } ? U : never
 
 // biome-ignore lint/suspicious/noExplicitAny: any is necessary for the operator function
 export interface Operator<I extends any[], O, Op extends string> {
@@ -11,8 +11,13 @@ export interface Operator<I extends any[], O, Op extends string> {
     operator: Op
     <Exprs extends { [K in keyof I]: Expression<I[K]> | I[K] }>(
         ...exprs: Exprs
+    ): ValueExpression<
+        O,
+        { [K in keyof I]: AsExpression<Exprs[K]> },
+        FactsFomExprs<Exprs[number]>,
         // biome-ignore lint/suspicious/noExplicitAny: any is necessary for the operator function
-    ): ValueExpression<O, { [K in keyof I]: AsExpression<Exprs[K]> }, Extract<JSONExpr, Record<Op, any[] | JSONExpr>>>
+        Extract<JSONExpr, Record<Op, any[] | JSONExpr>>
+    >
 }
 
 export function operator<I extends unknown[], O, Op extends string = string>({
@@ -25,10 +30,7 @@ export function operator<I extends unknown[], O, Op extends string = string>({
     symbol: string
 }): Operator<I, O, Op> {
     return Object.assign(
-        <Exprs extends { [K in keyof I]: Expression<I[K]> | I[K] }>(
-            ...exprs: Exprs
-            // biome-ignore lint/suspicious/noExplicitAny: any is necessary for the operator function
-        ): ValueExpression<O, { [K in keyof I]: AsExpression<Exprs[K]> }, Extract<JSONExpr, Record<Op, any[] | JSONExpr>>> => {
+        <Exprs extends { [K in keyof I]: Expression<I[K]> | I[K] }>(...exprs: Exprs) => {
             const xs = exprs.map((x) => fromLiteral(x as I[number]))
             return {
                 fn,
@@ -39,16 +41,11 @@ export function operator<I extends unknown[], O, Op extends string = string>({
                 [inspect.custom]() {
                     return `${symbol}(${xs.map((x) => x[inspect.custom]?.() ?? '').join(', ')})`
                 },
-            } as unknown as ValueExpression<
-                O,
-                { [K in keyof I]: AsExpression<Exprs[K]> },
-                // biome-ignore lint/suspicious/noExplicitAny: any is necessary for the operator function
-                Extract<JSONExpr, Record<Op, any[] | JSONExpr>>
-            >
+            }
         },
         {
             symbol,
             operator,
         },
-    )
+    ) as unknown as Operator<I, O, Op>
 }
diff --git a/src/engine/policy.ts b/src/engine/policy.ts
index febd67e..0e068f2 100644
--- a/src/engine/policy.ts
+++ b/src/engine/policy.ts
@@ -1,6 +1,7 @@
 import { collect, stack } from '@skyleague/axioms'
-import type { Simplify, UnionToIntersection } from '@skyleague/axioms/types'
+import type { IsEmptyObject, Simplify } from '@skyleague/axioms/types'
 import { version } from '../../package.json'
+import type { FactsFomExprs } from './operator.js'
 import type { Expression, ExpressionReturnType } from './types.js'
 
 export class EvaluationContext {
@@ -73,23 +74,18 @@ function* collapseExpression(root: Expression[], seen = new WeakSet()) {
 
 type InferFactName<Expr, k> = Expr extends { name: string } ? Expr['name'] : k
 
-type FilterFactExpressions<Facts extends Record<string, unknown>, k extends keyof Facts> = Facts[k] extends {
+type FilterFactExpressions<Facts, K extends keyof Facts> = Facts[K] extends {
     _type: 'fact'
 }
-    ? InferFactName<Facts[k], k>
+    ? InferFactName<Facts[K], K>
     : never
 
-type CollapseTreeToArray<T> = T extends { dependsOn: (infer U)[] } ? T | CollapseTreeToArray<U> : T
-type _InputFromExpressions<Facts extends Record<string, unknown>> = Simplify<{
-    [k in keyof Facts as FilterFactExpressions<Facts, k>]: ExpressionReturnType<Facts[k]>
+type _InputFromExpressions<Facts> = Simplify<{
+    [K in keyof Facts as FilterFactExpressions<Facts, K>]: ExpressionReturnType<Facts[K]>
 }>
-type NamedUnionToRecord<T> = T extends { name: infer Name } ? (Name extends PropertyKey ? { [k in Name]: T } : never) : never
-
+type _FactsFomExprs<Facts> = Facts extends unknown[] ? Facts[number] : Facts
 export type InputFromExpressions<Facts extends Record<string, unknown>> = Simplify<
-    _InputFromExpressions<Facts> &
-        _InputFromExpressions<
-            UnionToIntersection<NamedUnionToRecord<Facts extends Record<string, infer E> ? CollapseTreeToArray<E> : never>>
-        >
+    _InputFromExpressions<Facts> & _InputFromExpressions<{ [K in keyof Facts]: _FactsFomExprs<FactsFomExprs<Facts[K]>> }>
 >
 
 export type OutputFromFacts<Facts extends Record<string, unknown>> = Simplify<{
@@ -97,13 +93,12 @@ export type OutputFromFacts<Facts extends Record<string, unknown>> = Simplify<{
 }>
 
 export interface Policy<I, O> {
-    evaluate: [I] extends [never] ? () => { input: I; output: O } : (x: I) => { input: I; output: O }
+    evaluate: IsEmptyObject<I> extends true ? () => { input: I; output: O } : (x: I) => { input: I; output: O }
     expr: () => unknown
 }
 
 export function $policy<Facts extends Record<string, Expression>>(
     expressions: Facts,
-    // @ts-ignore
 ): Policy<InputFromExpressions<Facts>, OutputFromFacts<Facts>> {
     const facts = Object.entries(expressions).map(([name, e]) => {
         if (e.name === undefined) {
@@ -122,7 +117,6 @@ export function $policy<Facts extends Record<string, Expression>>(
     const properties = Object.fromEntries(inputNodes.map((e) => [e.name, e.expr('definition')]))
     const outputExpression = Object.fromEntries(outputNodes.map((f) => [f.name, f.expr('expression')]))
     return {
-        // @ts-ignore
         evaluate: ((input: Record<string, unknown>) => {
             const ctx = new EvaluationContext(input)
 
diff --git a/src/engine/types.spec.ts b/src/engine/types.spec.ts
index d7d6d81..59db747 100644
--- a/src/engine/types.spec.ts
+++ b/src/engine/types.spec.ts
@@ -23,10 +23,10 @@ describe('fromLiteral', () => {
         const fact = $fact(Arithmetic, 'input')
         const fa = fromLiteral($from(fact, '$.a'))
         const _fa_: Expression<number> = fa
-        expectTypeOf(fa).toEqualTypeOf<From<Arithmetic, number, [Fact<Arithmetic, 'input'>]>>()
+        expectTypeOf(fa).toEqualTypeOf<From<Arithmetic, number, Fact<Arithmetic, 'input'>>>()
         const fb = fromLiteral($from(fact, '$.b'))
         const _fb_: Expression<number> = fb
-        expectTypeOf(fb).toEqualTypeOf<From<Arithmetic, number, [Fact<Arithmetic, 'input'>]>>()
+        expectTypeOf(fb).toEqualTypeOf<From<Arithmetic, number, Fact<Arithmetic, 'input'>>>()
 
         type val = ['1', '2']
         const _test_multiple = {} as { [K in keyof val]: AsExpression<val[K]> }
diff --git a/src/engine/types.ts b/src/engine/types.ts
index fce02c3..c284b0d 100644
--- a/src/engine/types.ts
+++ b/src/engine/types.ts
@@ -1,6 +1,6 @@
 import type { EvaluationContext } from './policy.js'
 
-import { $literal } from '../expressions/input.js'
+import { $literal, type Fact } from '../expressions/input.js'
 import type {
     BooleanArrExpr,
     BooleanExpr,
@@ -40,6 +40,7 @@ export interface Expression<O = any, I = any, Expr extends JSONExpr | ValueItemE
     _type?: string
     name?: PropertyKey
     dependsOn: Expression[]
+    // facts?: Expression[]
     fn: (x: I, ctx: EvaluationContext) => O
     expr: (definition: DefinitionType) => Expr
     [inspect.custom]?(): string
@@ -50,20 +51,23 @@ export type ExpressionReturnType<E> = E extends Pick<Expression, 'fn'> ? ReturnT
 // biome-ignore lint/suspicious/noExplicitAny: this is needed for greedy matching
 export interface LiteralExpression<O = any, Expr extends JSONExpr = InferExpressionType<O>> extends Expression<O, any, Expr> {
     dependsOn: []
+    // facts: []
     _type: 'literal'
 }
 
-export interface FactExpression<T, Expr extends JSONExpr = InferExpressionType<T>> extends Expression<T, unknown, Expr> {
+// biome-ignore lint/suspicious/noExplicitAny: this is needed for greedy matching
+export interface FactExpression<T = any, Expr extends JSONExpr = InferExpressionType<T>> extends Expression<T, unknown, Expr> {
     _type: 'fact'
 }
 
 export interface InputExpression<
     O,
     I,
-    DependsOn extends Expression[],
+    F extends Fact<Expression, string>,
     Expr extends JSONExpr | ValueItemExpr = InferExpressionType<O>,
 > extends Expression<O, I, Expr> {
-    dependsOn: DependsOn
+    dependsOn: [F]
+    facts: [F]
     _type: 'value' | 'literal'
 }
 
@@ -71,9 +75,10 @@ export type InputFromExpressions<Expr extends Expression[]> = {
     [k in keyof Expr]: ExpressionReturnType<Expr[k]>
 }
 
-export interface ValueExpression<O, DependsOn extends Expression[], Expr extends JSONExpr = InferExpressionType<O>>
+export interface ValueExpression<O, DependsOn extends Expression[], Facts, Expr extends JSONExpr = InferExpressionType<O>>
     extends Expression<O, InputFromExpressions<DependsOn>, Expr> {
-    dependsOn: DependsOn
+    // dependsOn: DependsOn
+    facts: Facts //extends FactExpression ? [Facts] : never
     _type?: 'value'
 }
 
diff --git a/src/expressions/boolean.spec.ts b/src/expressions/boolean.spec.ts
index 84824da..d7cec74 100644
--- a/src/expressions/boolean.spec.ts
+++ b/src/expressions/boolean.spec.ts
@@ -90,14 +90,20 @@ describe('startsWith', () => {
 
         const x1 = $startsWith('1', '2')
         expectTypeOf(x1).toEqualTypeOf<
-            ValueExpression<boolean, [LiteralExpression<'1', StringExpr>, LiteralExpression<'2', StringExpr>], StartsWithExpr>
+            ValueExpression<
+                boolean,
+                [LiteralExpression<'1', StringExpr>, LiteralExpression<'2', StringExpr>],
+                never,
+                StartsWithExpr
+            >
         >()
 
         const x2 = $startsWith($from(fact, '$.a'), '2')
         expectTypeOf(x2).toEqualTypeOf<
             ValueExpression<
                 boolean,
-                [From<AbObj, string, [Fact<AbObj, 'input'>]>, LiteralExpression<'2', StringExpr>],
+                [str: From<AbObj, string, Fact<AbObj, 'input'>>, searchString: LiteralExpression<'2', StringExpr>],
+                [Fact<AbObj, 'input'>],
                 StartsWithExpr
             >
         >()
@@ -106,7 +112,8 @@ describe('startsWith', () => {
         expectTypeOf(x3).toEqualTypeOf<
             ValueExpression<
                 boolean,
-                [LiteralExpression<'2', StringExpr>, From<AbObj, string, [Fact<AbObj, 'input'>]>],
+                [str: LiteralExpression<'2', StringExpr>, searchString: From<AbObj, string, Fact<AbObj, 'input'>>],
+                [Fact<AbObj, 'input'>],
                 StartsWithExpr
             >
         >()
@@ -190,14 +197,20 @@ describe('endsWith', () => {
 
         const x1 = $endsWith('1', '2')
         expectTypeOf(x1).toEqualTypeOf<
-            ValueExpression<boolean, [LiteralExpression<'1', StringExpr>, LiteralExpression<'2', StringExpr>], EndsWithExpr>
+            ValueExpression<
+                boolean,
+                [str: LiteralExpression<'1', StringExpr>, searchString: LiteralExpression<'2', StringExpr>],
+                never,
+                EndsWithExpr
+            >
         >()
 
         const x2 = $endsWith($from(fact, '$.a'), '2')
         expectTypeOf(x2).toEqualTypeOf<
             ValueExpression<
                 boolean,
-                [From<AbObj, string, [Fact<AbObj, 'input'>]>, LiteralExpression<'2', StringExpr>],
+                [str: From<AbObj, string, Fact<AbObj, 'input'>>, searchString: LiteralExpression<'2', StringExpr>],
+                [Fact<AbObj, 'input'>],
                 EndsWithExpr
             >
         >()
@@ -206,7 +219,8 @@ describe('endsWith', () => {
         expectTypeOf(x3).toEqualTypeOf<
             ValueExpression<
                 boolean,
-                [LiteralExpression<'2', StringExpr>, From<AbObj, string, [Fact<AbObj, 'input'>]>],
+                [str: LiteralExpression<'2', StringExpr>, searchString: From<AbObj, string, Fact<AbObj, 'input'>>],
+                [Fact<AbObj, 'input'>],
                 EndsWithExpr
             >
         >()
@@ -290,14 +304,20 @@ describe('includes', () => {
 
         const x1 = $includes('1', '2')
         expectTypeOf(x1).toEqualTypeOf<
-            ValueExpression<boolean, [LiteralExpression<'1', StringExpr>, LiteralExpression<'2', StringExpr>], IncludesExpr>
+            ValueExpression<
+                boolean,
+                [LiteralExpression<'1', StringExpr>, LiteralExpression<'2', StringExpr>],
+                never,
+                IncludesExpr
+            >
         >()
 
         const x2 = $includes($from(fact, '$.a'), '2')
         expectTypeOf(x2).toEqualTypeOf<
             ValueExpression<
                 boolean,
-                [From<AbObj, string, [Fact<AbObj, 'input'>]>, LiteralExpression<'2', StringExpr>],
+                [str: From<AbObj, string, Fact<AbObj, 'input'>>, searchString: LiteralExpression<'2', StringExpr>],
+                [Fact<AbObj, 'input'>],
                 IncludesExpr
             >
         >()
@@ -306,7 +326,8 @@ describe('includes', () => {
         expectTypeOf(x3).toEqualTypeOf<
             ValueExpression<
                 boolean,
-                [LiteralExpression<'2', StringExpr>, From<AbObj, string, [Fact<AbObj, 'input'>]>],
+                [str: LiteralExpression<'2', StringExpr>, searchString: From<AbObj, string, Fact<AbObj, 'input'>>],
+                [Fact<AbObj, 'input'>],
                 IncludesExpr
             >
         >()
@@ -413,7 +434,9 @@ describe('all', () => {
         const fact = $fact(LogicObj, 'input')
 
         const x1 = $all([1, 2], (x) => $equal(x, 1))
-        expectTypeOf(x1).toEqualTypeOf<ValueExpression<boolean, [LiteralExpression<number[], NumberArrExpr>], BooleanExpr>>()
+        expectTypeOf(x1).toEqualTypeOf<
+            ValueExpression<boolean, [LiteralExpression<number[], NumberArrExpr>], never, BooleanExpr>
+        >()
 
         const a = $from(fact, '$.d')
         const x2 = $all(a, (x) => $equal(x, 1))
@@ -427,9 +450,10 @@ describe('all', () => {
                             a: boolean
                             b: boolean
                         }[],
-                        [Fact<LogicObj, 'input'>]
+                        Fact<LogicObj, 'input'>
                     >,
                 ],
+                [Fact<LogicObj, 'input'>],
                 BooleanExpr
             >
         >()
@@ -437,7 +461,7 @@ describe('all', () => {
         const ba = $from(fact, '$.b..a')
         const x3 = $all(ba, (x) => $equal(x, 1))
         expectTypeOf(x3).toEqualTypeOf<
-            ValueExpression<boolean, [From<LogicObj, never[], [Fact<LogicObj, 'input'>]>], BooleanExpr>
+            ValueExpression<boolean, [From<LogicObj, never[], Fact<LogicObj, 'input'>>], [Fact<LogicObj, 'input'>], BooleanExpr>
         >()
     })
 })
@@ -542,7 +566,9 @@ describe('any', () => {
         const fact = $fact(LogicObj, 'input')
 
         const x1 = $any([1, 2], (x) => $equal(x, 1))
-        expectTypeOf(x1).toEqualTypeOf<ValueExpression<boolean, [LiteralExpression<number[], NumberArrExpr>], BooleanExpr>>()
+        expectTypeOf(x1).toEqualTypeOf<
+            ValueExpression<boolean, [LiteralExpression<number[], NumberArrExpr>], never, BooleanExpr>
+        >()
 
         const a = $from(fact, '$.d')
         const x2 = $any(a, (x) => $equal(x, 1))
@@ -556,9 +582,10 @@ describe('any', () => {
                             a: boolean
                             b: boolean
                         }[],
-                        [Fact<LogicObj, 'input'>]
+                        Fact<LogicObj, 'input'>
                     >,
                 ],
+                [Fact<LogicObj, 'input'>],
                 BooleanExpr
             >
         >()
@@ -566,7 +593,7 @@ describe('any', () => {
         const ba = $from(fact, '$.b..a')
         const x3 = $any(ba, (x) => $equal(x, 1))
         expectTypeOf(x3).toEqualTypeOf<
-            ValueExpression<boolean, [From<LogicObj, never[], [Fact<LogicObj, 'input'>]>], BooleanExpr>
+            ValueExpression<boolean, [From<LogicObj, never[], Fact<LogicObj, 'input'>>], [Fact<LogicObj, 'input'>], BooleanExpr>
         >()
     })
 })
diff --git a/src/expressions/boolean.ts b/src/expressions/boolean.ts
index d6a6a9d..07de8eb 100644
--- a/src/expressions/boolean.ts
+++ b/src/expressions/boolean.ts
@@ -1,6 +1,6 @@
 import { $value, type ValueItem } from './higher-order-fn.js'
 
-import { operator } from '../engine/operator.js'
+import { type FactsFomExprs, operator } from '../engine/operator.js'
 import {
     type AsExpression,
     type Expression,
@@ -44,7 +44,7 @@ export const $all = Object.assign(
     <Expr extends LiteralOr<any[]>>(
         xs: Expr,
         predicate: (value: ValueItem<ExpressionTypeOfLiteral<Expr>>) => Expression<boolean>,
-    ): ValueExpression<boolean, [AsExpression<Expr>]> => {
+    ): ValueExpression<boolean, [AsExpression<Expr>], FactsFomExprs<Expr>> => {
         const _xs = fromLiteral(xs)
         const _value = $value<ExpressionTypeOfLiteral<Expr>>()
         const _transform = predicate(_value)
@@ -59,7 +59,7 @@ export const $all = Object.assign(
             [inspect.custom]() {
                 return `$all(${_xs[inspect.custom]?.() ?? ''}, (x) => ${_transform[inspect.custom]?.() ?? ''})`
             },
-        } as ValueExpression<boolean, [AsExpression<Expr>]>
+        } as ValueExpression<boolean, [AsExpression<Expr>], FactsFomExprs<Expr>>
     },
     // biome-ignore lint/suspicious/noExplicitAny: this is needed for greedy matching
     { operator: 'all', symbol: '$all', parse: (xs: any, predicate: any) => $all(xs, () => predicate) } as const,
@@ -70,7 +70,7 @@ export const $any = Object.assign(
     <Expr extends LiteralOr<any[]>>(
         xs: Expr,
         predicate: (value: ValueItem<ExpressionTypeOfLiteral<Expr>>) => Expression<boolean>,
-    ): ValueExpression<boolean, [AsExpression<Expr>]> => {
+    ): ValueExpression<boolean, [AsExpression<Expr>], FactsFomExprs<Expr>> => {
         const _xs = fromLiteral(xs)
         const _value = $value<ExpressionTypeOfLiteral<Expr>>()
         const _transform = predicate(_value)
@@ -85,7 +85,7 @@ export const $any = Object.assign(
             [inspect.custom]() {
                 return `$any(${_xs[inspect.custom]?.() ?? ''}, (x) => ${_transform[inspect.custom]?.() ?? ''})`
             },
-        } as ValueExpression<boolean, [AsExpression<Expr>]>
+        } as ValueExpression<boolean, [AsExpression<Expr>], FactsFomExprs<Expr>>
     },
     // biome-ignore lint/suspicious/noExplicitAny: this is needed for greedy matching
     { operator: 'any', symbol: '$any', parse: (xs: any, predicate: any) => $any(xs, () => predicate) } as const,
diff --git a/src/expressions/higher-order-fn.spec.ts b/src/expressions/higher-order-fn.spec.ts
index e21b573..b640bae 100644
--- a/src/expressions/higher-order-fn.spec.ts
+++ b/src/expressions/higher-order-fn.spec.ts
@@ -181,20 +181,26 @@ describe('map', () => {
         const fact = $fact(MathFn, 'input')
 
         const x1 = $map([1, 2], (x) => x)
-        expectTypeOf(x1).toEqualTypeOf<ValueExpression<number[], [LiteralExpression<number[], NumberArrExpr>], NumberExpr>>()
+        expectTypeOf(x1).toEqualTypeOf<
+            ValueExpression<number[], [LiteralExpression<number[], NumberArrExpr>], never, NumberExpr>
+        >()
 
         const a = $from(fact, '$.a')
         const x2 = $map(a, (x) => x)
-        expectTypeOf(x2).toEqualTypeOf<ValueExpression<number[], [From<MathFn, number[], [Fact<MathFn, 'input'>]>], NumberExpr>>()
+        expectTypeOf(x2).toEqualTypeOf<
+            ValueExpression<number[], [From<MathFn, number[], Fact<MathFn, 'input'>>], [Fact<MathFn, 'input'>], NumberExpr>
+        >()
 
         const ba = $from(fact, '$.b..a')
         const x3 = $map(ba, (x) => x)
-        expectTypeOf(x3).toEqualTypeOf<ValueExpression<number[], [From<MathFn, number[], [Fact<MathFn, 'input'>]>], NumberExpr>>()
+        expectTypeOf(x3).toEqualTypeOf<
+            ValueExpression<number[], [From<MathFn, number[], Fact<MathFn, 'input'>>], [Fact<MathFn, 'input'>], NumberExpr>
+        >()
 
         const b = $from(fact, '$.b')
         const x4 = $map(b, (x) => x('$.a'))
         expectTypeOf(x4).toEqualTypeOf<
-            ValueExpression<number[], [From<MathFn, Arithmetic[], [Fact<MathFn, 'input'>]>], NumberExpr>
+            ValueExpression<number[], [From<MathFn, Arithmetic[], Fact<MathFn, 'input'>>], [Fact<MathFn, 'input'>], NumberExpr>
         >()
     })
 })
@@ -285,24 +291,26 @@ describe('filter', () => {
         const fact = $fact(MathFn, 'input')
 
         const x1 = $filter([1, 2], (x) => $equal(x, 1))
-        expectTypeOf(x1).toEqualTypeOf<ValueExpression<number[], [LiteralExpression<number[], NumberArrExpr>], NumberArrExpr>>()
+        expectTypeOf(x1).toEqualTypeOf<
+            ValueExpression<number[], [LiteralExpression<number[], NumberArrExpr>], never, NumberArrExpr>
+        >()
 
         const a = $from(fact, '$.a')
         const x2 = $filter(a, (x) => $equal(x, 1))
         expectTypeOf(x2).toEqualTypeOf<
-            ValueExpression<number[], [From<MathFn, number[], [Fact<MathFn, 'input'>]>], NumberArrExpr>
+            ValueExpression<number[], [From<MathFn, number[], Fact<MathFn, 'input'>>], [Fact<MathFn, 'input'>], NumberArrExpr>
         >()
 
         const ba = $from(fact, '$.b..a')
         const x3 = $filter(ba, (x) => $equal(x, 1))
         expectTypeOf(x3).toEqualTypeOf<
-            ValueExpression<number[], [From<MathFn, number[], [Fact<MathFn, 'input'>]>], NumberArrExpr>
+            ValueExpression<number[], [From<MathFn, number[], Fact<MathFn, 'input'>>], [Fact<MathFn, 'input'>], NumberArrExpr>
         >()
 
         const b = $from(fact, '$.b')
         const x4 = $filter(b, (x) => $equal(1, x('$.a')))
         expectTypeOf(x4).toEqualTypeOf<
-            ValueExpression<Arithmetic[], [From<MathFn, Arithmetic[], [Fact<MathFn, 'input'>]>], JSONExpr>
+            ValueExpression<Arithmetic[], [From<MathFn, Arithmetic[], Fact<MathFn, 'input'>>], [Fact<MathFn, 'input'>], JSONExpr>
         >()
     })
 })
diff --git a/src/expressions/higher-order-fn.ts b/src/expressions/higher-order-fn.ts
index 9c138fe..f1ea816 100644
--- a/src/expressions/higher-order-fn.ts
+++ b/src/expressions/higher-order-fn.ts
@@ -1,3 +1,4 @@
+import type { FactsFomExprs } from '../engine/operator.js'
 import type { EvaluationContext } from '../engine/policy.js'
 import {
     type AsExpression,
@@ -16,7 +17,7 @@ import { JSONPath, type JSONPathValue } from '@skyleague/jsonpath'
 import { inspect } from 'node:util'
 
 // biome-ignore lint/suspicious/noExplicitAny: this is needed for greedy matching
-export interface Value<O> extends InputExpression<O, any, [], ValueItemExpr> {
+export interface Value<O> extends InputExpression<O, any, never, ValueItemExpr> {
     _type: 'value'
 }
 function value<T, P extends string | undefined = undefined>(path?: P): P extends string ? Value<JSONPathValue<T, P>> : Value<T> {
@@ -62,7 +63,12 @@ export const $map = Object.assign(
     <O extends LiteralOr<any>, Expr extends LiteralOr<any[]>>(
         xs: Expr,
         transform: (value: ValueItem<ExpressionTypeOfLiteral<Expr>>) => AsExpression<O>,
-    ): ValueExpression<ExpressionTypeOfLiteral<O>[], [AsExpression<Expr>], InferExpressionType<ExpressionTypeOfLiteral<O>>> => {
+    ): ValueExpression<
+        ExpressionTypeOfLiteral<O>[],
+        [AsExpression<Expr>],
+        FactsFomExprs<Expr>,
+        InferExpressionType<ExpressionTypeOfLiteral<O>>
+    > => {
         const _xs = fromLiteral(xs)
         const _value = $value<ExpressionTypeOfLiteral<Expr>>()
         const _transform = transform(_value)
@@ -77,7 +83,12 @@ export const $map = Object.assign(
             [inspect.custom]() {
                 return `$map(${_xs[inspect.custom]?.() ?? ''}, (x) => ${_transform[inspect.custom]?.() ?? ''})`
             },
-        } as ValueExpression<ExpressionTypeOfLiteral<O>[], [AsExpression<Expr>], InferExpressionType<ExpressionTypeOfLiteral<O>>>
+        } as ValueExpression<
+            ExpressionTypeOfLiteral<O>[],
+            [AsExpression<Expr>],
+            FactsFomExprs<Expr>,
+            InferExpressionType<ExpressionTypeOfLiteral<O>>
+        >
     },
     // biome-ignore lint/suspicious/noExplicitAny: this is needed for greedy matching
     { operator: 'map', symbol: '$map', parse: (xs: any, transform: any) => $map(xs, () => transform) } as const,
@@ -91,6 +102,7 @@ export const $filter = Object.assign(
     ): ValueExpression<
         ExpressionTypeOfLiteral<Expr>,
         [AsExpression<Expr>],
+        FactsFomExprs<Expr>,
         InferExpressionType<ExpressionTypeOfLiteral<Expr>>
     > => {
         const _xs = fromLiteral(xs)
@@ -110,6 +122,7 @@ export const $filter = Object.assign(
         } as ValueExpression<
             ExpressionTypeOfLiteral<Expr>,
             [AsExpression<Expr>],
+            FactsFomExprs<Expr>,
             InferExpressionType<ExpressionTypeOfLiteral<Expr>>
         >
     },
diff --git a/src/expressions/input.ts b/src/expressions/input.ts
index d11c9f8..41d130f 100644
--- a/src/expressions/input.ts
+++ b/src/expressions/input.ts
@@ -1,11 +1,4 @@
-import type {
-    DefinitionType,
-    Expression,
-    FactExpression,
-    InferExpressionType,
-    InputExpression,
-    LiteralExpression,
-} from '../engine/types.js'
+import type { DefinitionType, FactExpression, InferExpressionType, InputExpression, LiteralExpression } from '../engine/types.js'
 import type { FromExpr } from '../json/jsonexpr.type.js'
 
 import { JSONPath, type JSONPathValue } from '@skyleague/jsonpath'
@@ -13,7 +6,8 @@ import type { Schema } from '@skyleague/therefore'
 
 import { inspect } from 'node:util'
 
-export interface Fact<T, Name extends string> extends FactExpression<T> {
+// biome-ignore lint/suspicious/noExplicitAny: this is needed for greedy matching
+export interface Fact<T = any, Name extends string = string> extends FactExpression<T> {
     name: Name
     dependsOn: []
     _type: 'fact'
@@ -34,32 +28,32 @@ export function $fact<T, Name extends string>(schema: Pick<Schema<T>, 'schema' |
         },
     }
 }
-export interface From<I, O, DependsOn extends Expression[]> extends InputExpression<O, I, DependsOn, FromExpr> {
+export interface From<I, O, F extends Fact> extends InputExpression<O, I, F, FromExpr> {
     _type: 'value'
 }
 
-export function $from<T, Name extends string>(fact: Fact<T, Name>): From<T, JSONPathValue<T, '$'>, [Fact<T, Name>]>
+export function $from<T, Name extends string>(fact: Fact<T, Name>): From<T, JSONPathValue<T, '$'>, Fact<T, Name>>
 export function $from<T, P extends string, Name extends string>(
     fact: Fact<T, Name>,
     path: P,
-): From<T, JSONPathValue<T, P>, [Fact<T, Name>]>
+): From<T, JSONPathValue<T, P>, Fact<T, Name>>
 export function $from<T, P extends string, Name extends string>(
     fact: Fact<T, Name>,
     path: P = '$' as P,
-): From<T, JSONPathValue<T, P>, [Fact<T, Name>]> {
+): From<T, JSONPathValue<T, P>, Fact<T, Name>> {
     return {
         _type: 'value',
         dependsOn: [fact],
         fn: ((_: unknown, ctx: { input: Record<Name, T> }) => JSONPath.get(ctx.input[fact.name], path)) as From<
             T,
             JSONPathValue<T, P>,
-            [Fact<T, Name>]
+            Fact<T, Name>
         >['fn'],
-        expr: (_definition) => ({ from: [fact.name, path.toString()] as const }),
+        expr: () => ({ from: [fact.name, path.toString()] as const }),
         [inspect.custom]() {
             return `$from(${fact[inspect.custom]?.() ?? `"${fact.name}"`}${path === '$' ? '' : `, "${path}"`})`
         },
-    }
+    } as unknown as From<T, JSONPathValue<T, P>, Fact<T, Name>>
 }
 
 export function $literal<O>(x: O): LiteralExpression<O> {
diff --git a/src/expressions/logic.spec.ts b/src/expressions/logic.spec.ts
index 38b330e..26624d9 100644
--- a/src/expressions/logic.spec.ts
+++ b/src/expressions/logic.spec.ts
@@ -76,6 +76,7 @@ describe('if', () => {
                     LiteralExpression<number, NumberExpr>,
                     LiteralExpression<number, NumberExpr>,
                 ],
+                never,
                 IfExpr
             >
         >()
@@ -89,6 +90,7 @@ describe('if', () => {
                     LiteralExpression<number, NumberExpr>,
                     LiteralExpression<string, StringExpr>,
                 ],
+                never,
                 IfExpr
             >
         >()
@@ -154,14 +156,20 @@ describe('and', () => {
 
         const x1 = $and(false, true, false)
         expectTypeOf(x1).toEqualTypeOf<
-            ValueExpression<boolean, (LiteralExpression<false, BooleanExpr> | LiteralExpression<true, BooleanExpr>)[], AndExpr>
+            ValueExpression<
+                boolean,
+                (LiteralExpression<false, BooleanExpr> | LiteralExpression<true, BooleanExpr>)[],
+                never,
+                AndExpr
+            >
         >()
 
         const x2 = $and($from(fact, '$.c'), true)
         expectTypeOf(x2).toEqualTypeOf<
             ValueExpression<
                 boolean,
-                (LiteralExpression<true, BooleanExpr> | From<LogicObj, boolean, [Fact<LogicObj, 'input'>]>)[],
+                (LiteralExpression<true, BooleanExpr> | From<LogicObj, boolean, Fact<LogicObj, 'input'>>)[],
+                [Fact<LogicObj, 'input'>],
                 AndExpr
             >
         >()
@@ -170,7 +178,8 @@ describe('and', () => {
         expectTypeOf(x3).toEqualTypeOf<
             ValueExpression<
                 boolean,
-                (LiteralExpression<true, BooleanExpr> | From<LogicObj, boolean, [Fact<LogicObj, 'input'>]>)[],
+                (From<LogicObj, boolean, Fact<LogicObj, 'input'>> | LiteralExpression<true, BooleanExpr>)[],
+                [Fact<LogicObj, 'input'>],
                 AndExpr
             >
         >()
@@ -236,14 +245,20 @@ describe('or', () => {
 
         const x1 = $or(false, true, false)
         expectTypeOf(x1).toEqualTypeOf<
-            ValueExpression<boolean, (LiteralExpression<false, BooleanExpr> | LiteralExpression<true, BooleanExpr>)[], OrExpr>
+            ValueExpression<
+                boolean,
+                (LiteralExpression<false, BooleanExpr> | LiteralExpression<true, BooleanExpr>)[],
+                never,
+                OrExpr
+            >
         >()
 
         const x2 = $or($from(fact, '$.c'), true)
         expectTypeOf(x2).toEqualTypeOf<
             ValueExpression<
                 boolean,
-                (LiteralExpression<true, BooleanExpr> | From<LogicObj, boolean, [Fact<LogicObj, 'input'>]>)[],
+                (From<LogicObj, boolean, Fact<LogicObj, 'input'>> | LiteralExpression<true, BooleanExpr>)[],
+                [Fact<LogicObj, 'input'>],
                 OrExpr
             >
         >()
@@ -252,7 +267,8 @@ describe('or', () => {
         expectTypeOf(x3).toEqualTypeOf<
             ValueExpression<
                 boolean,
-                (LiteralExpression<true, BooleanExpr> | From<LogicObj, boolean, [Fact<LogicObj, 'input'>]>)[],
+                (From<LogicObj, boolean, Fact<LogicObj, 'input'>> | LiteralExpression<true, BooleanExpr>)[],
+                [Fact<LogicObj, 'input'>],
                 OrExpr
             >
         >()
diff --git a/src/expressions/logic.ts b/src/expressions/logic.ts
index 8234604..4735171 100644
--- a/src/expressions/logic.ts
+++ b/src/expressions/logic.ts
@@ -1,4 +1,4 @@
-import { operator } from '../engine/operator.js'
+import { type FactsFomExprs, operator } from '../engine/operator.js'
 import {
     type AsExpression,
     type Expression,
@@ -18,6 +18,7 @@ export const $if = Object.assign(
     ): ValueExpression<
         ExpressionTypeOfLiteral<UE> | ExpressionTypeOfLiteral<VE>,
         [AsExpression<CE>, AsExpression<UE>, AsExpression<VE>],
+        FactsFomExprs<CE | UE | VE>,
         IfExpr
     > => {
         const condition = fromLiteral(_condition)
@@ -29,6 +30,7 @@ export const $if = Object.assign(
             expr: (mod) => ({
                 if: [condition.expr(mod), a.expr(mod), b.expr(mod)],
             }),
+            facts: undefined as never,
         }
     },
     { operator: 'if', symbol: '$if' },
diff --git a/src/expressions/number-array.spec.ts b/src/expressions/number-array.spec.ts
index eee34a1..5ff90bf 100644
--- a/src/expressions/number-array.spec.ts
+++ b/src/expressions/number-array.spec.ts
@@ -99,15 +99,19 @@ describe('min', () => {
         const fact = $fact(MathFn, 'input')
 
         const x1 = $min([1, 2])
-        expectTypeOf(x1).toEqualTypeOf<ValueExpression<number, [LiteralExpression<number[], NumberArrExpr>], MinExpr>>()
+        expectTypeOf(x1).toEqualTypeOf<ValueExpression<number, [LiteralExpression<number[], NumberArrExpr>], never, MinExpr>>()
 
         const a = $from(fact, '$.a')
         const x2 = $min(a)
-        expectTypeOf(x2).toEqualTypeOf<ValueExpression<number, [From<MathFn, number[], [Fact<MathFn, 'input'>]>], MinExpr>>()
+        expectTypeOf(x2).toEqualTypeOf<
+            ValueExpression<number, [From<MathFn, number[], Fact<MathFn, 'input'>>], [Fact<MathFn, 'input'>], MinExpr>
+        >()
 
         const b = $from(fact, '$.b..a')
         const x3 = $min(b)
-        expectTypeOf(x3).toEqualTypeOf<ValueExpression<number, [From<MathFn, number[], [Fact<MathFn, 'input'>]>], MinExpr>>()
+        expectTypeOf(x3).toEqualTypeOf<
+            ValueExpression<number, [From<MathFn, number[], Fact<MathFn, 'input'>>], [Fact<MathFn, 'input'>], MinExpr>
+        >()
     })
 })
 
@@ -198,14 +202,18 @@ describe('max', () => {
         const fact = $fact(MathFn, 'input')
 
         const x1 = $max([1, 2])
-        expectTypeOf(x1).toEqualTypeOf<ValueExpression<number, [LiteralExpression<number[], NumberArrExpr>], MaxExpr>>()
+        expectTypeOf(x1).toEqualTypeOf<ValueExpression<number, [LiteralExpression<number[], NumberArrExpr>], never, MaxExpr>>()
 
         const a = $from(fact, '$.a')
         const x2 = $max(a)
-        expectTypeOf(x2).toEqualTypeOf<ValueExpression<number, [From<MathFn, number[], [Fact<MathFn, 'input'>]>], MaxExpr>>()
+        expectTypeOf(x2).toEqualTypeOf<
+            ValueExpression<number, [From<MathFn, number[], Fact<MathFn, 'input'>>], [Fact<MathFn, 'input'>], MaxExpr>
+        >()
 
         const b = $from(fact, '$.b..a')
         const x3 = $max(b)
-        expectTypeOf(x3).toEqualTypeOf<ValueExpression<number, [From<MathFn, number[], [Fact<MathFn, 'input'>]>], MaxExpr>>()
+        expectTypeOf(x3).toEqualTypeOf<
+            ValueExpression<number, [From<MathFn, number[], Fact<MathFn, 'input'>>], [Fact<MathFn, 'input'>], MaxExpr>
+        >()
     })
 })
diff --git a/src/expressions/number.spec.ts b/src/expressions/number.spec.ts
index b035967..8f0cdda 100644
--- a/src/expressions/number.spec.ts
+++ b/src/expressions/number.spec.ts
@@ -88,14 +88,15 @@ describe('add', () => {
 
         const x1 = $add(1, 2)
         expectTypeOf(x1).toEqualTypeOf<
-            ValueExpression<number, [LiteralExpression<1, NumberExpr>, LiteralExpression<2, NumberExpr>], AddExpr>
+            ValueExpression<number, [LiteralExpression<1, NumberExpr>, LiteralExpression<2, NumberExpr>], never, AddExpr>
         >()
 
         const x2 = $add($from(fact, '$.a'), 2)
         expectTypeOf(x2).toEqualTypeOf<
             ValueExpression<
                 number,
-                [From<Arithmetic, number, [Fact<Arithmetic, 'input'>]>, LiteralExpression<2, NumberExpr>],
+                [From<Arithmetic, number, Fact<Arithmetic, 'input'>>, LiteralExpression<2, NumberExpr>],
+                [Fact<Arithmetic, 'input'>],
                 AddExpr
             >
         >()
@@ -104,7 +105,8 @@ describe('add', () => {
         expectTypeOf(x3).toEqualTypeOf<
             ValueExpression<
                 number,
-                [LiteralExpression<2, NumberExpr>, From<Arithmetic, number, [Fact<Arithmetic, 'input'>]>],
+                [LiteralExpression<2, NumberExpr>, From<Arithmetic, number, Fact<Arithmetic, 'input'>>],
+                [Fact<Arithmetic, 'input'>],
                 AddExpr
             >
         >()
@@ -181,7 +183,7 @@ describe('subtract', () => {
             const result = subs.evaluate()
 
             expectTypeOf(x1).toEqualTypeOf<
-                ValueExpression<number, [LiteralExpression<number>, LiteralExpression<number>], SubExpr>
+                ValueExpression<number, [LiteralExpression<number>, LiteralExpression<number>], never, SubExpr>
             >()
             expect(result.output.x1).toEqual(a - b)
         })
@@ -192,14 +194,15 @@ describe('subtract', () => {
 
         const x1 = $subtract(1, 2)
         expectTypeOf(x1).toEqualTypeOf<
-            ValueExpression<number, [LiteralExpression<1, NumberExpr>, LiteralExpression<2, NumberExpr>], SubExpr>
+            ValueExpression<number, [LiteralExpression<1, NumberExpr>, LiteralExpression<2, NumberExpr>], never, SubExpr>
         >()
 
         const x2 = $subtract($from(fact, '$.a'), 2)
         expectTypeOf(x2).toEqualTypeOf<
             ValueExpression<
                 number,
-                [From<Arithmetic, number, [Fact<Arithmetic, 'input'>]>, LiteralExpression<2, NumberExpr>],
+                [From<Arithmetic, number, Fact<Arithmetic, 'input'>>, LiteralExpression<2, NumberExpr>],
+                [Fact<Arithmetic, 'input'>],
                 SubExpr
             >
         >()
@@ -208,7 +211,8 @@ describe('subtract', () => {
         expectTypeOf(x3).toEqualTypeOf<
             ValueExpression<
                 number,
-                [LiteralExpression<2, NumberExpr>, From<Arithmetic, number, [Fact<Arithmetic, 'input'>]>],
+                [LiteralExpression<2, NumberExpr>, From<Arithmetic, number, Fact<Arithmetic, 'input'>>],
+                [Fact<Arithmetic, 'input'>],
                 SubExpr
             >
         >()
@@ -292,14 +296,15 @@ describe('multiply', () => {
 
         const x1 = $multiply(1, 2)
         expectTypeOf(x1).toEqualTypeOf<
-            ValueExpression<number, [LiteralExpression<1, NumberExpr>, LiteralExpression<2, NumberExpr>], MulExpr>
+            ValueExpression<number, [LiteralExpression<1, NumberExpr>, LiteralExpression<2, NumberExpr>], never, MulExpr>
         >()
 
         const x2 = $multiply($from(fact, '$.a'), 2)
         expectTypeOf(x2).toEqualTypeOf<
             ValueExpression<
                 number,
-                [From<Arithmetic, number, [Fact<Arithmetic, 'input'>]>, LiteralExpression<2, NumberExpr>],
+                [From<Arithmetic, number, Fact<Arithmetic, 'input'>>, LiteralExpression<2, NumberExpr>],
+                [Fact<Arithmetic, 'input'>],
                 MulExpr
             >
         >()
@@ -308,7 +313,8 @@ describe('multiply', () => {
         expectTypeOf(x3).toEqualTypeOf<
             ValueExpression<
                 number,
-                [LiteralExpression<2, NumberExpr>, From<Arithmetic, number, [Fact<Arithmetic, 'input'>]>],
+                [LiteralExpression<2, NumberExpr>, From<Arithmetic, number, Fact<Arithmetic, 'input'>>],
+                [Fact<Arithmetic, 'input'>],
                 MulExpr
             >
         >()
@@ -391,14 +397,15 @@ describe('divide', () => {
 
         const x1 = $divide(1, 2)
         expectTypeOf(x1).toEqualTypeOf<
-            ValueExpression<number, [LiteralExpression<1, NumberExpr>, LiteralExpression<2, NumberExpr>], DivExpr>
+            ValueExpression<number, [LiteralExpression<1, NumberExpr>, LiteralExpression<2, NumberExpr>], never, DivExpr>
         >()
 
         const x2 = $divide($from(fact, '$.a'), 2)
         expectTypeOf(x2).toEqualTypeOf<
             ValueExpression<
                 number,
-                [From<Arithmetic, number, [Fact<Arithmetic, 'input'>]>, LiteralExpression<2, NumberExpr>],
+                [From<Arithmetic, number, Fact<Arithmetic, 'input'>>, LiteralExpression<2, NumberExpr>],
+                [Fact<Arithmetic, 'input'>],
                 DivExpr
             >
         >()
@@ -407,7 +414,8 @@ describe('divide', () => {
         expectTypeOf(x3).toEqualTypeOf<
             ValueExpression<
                 number,
-                [LiteralExpression<2, NumberExpr>, From<Arithmetic, number, [Fact<Arithmetic, 'input'>]>],
+                [LiteralExpression<2, NumberExpr>, From<Arithmetic, number, Fact<Arithmetic, 'input'>>],
+                [Fact<Arithmetic, 'input'>],
                 DivExpr
             >
         >()
@@ -491,14 +499,15 @@ describe('mod', () => {
 
         const x1 = $modulo(1, 2)
         expectTypeOf(x1).toEqualTypeOf<
-            ValueExpression<number, [LiteralExpression<1, NumberExpr>, LiteralExpression<2, NumberExpr>], ModExpr>
+            ValueExpression<number, [LiteralExpression<1, NumberExpr>, LiteralExpression<2, NumberExpr>], never, ModExpr>
         >()
 
         const x2 = $modulo($from(fact, '$.a'), 2)
         expectTypeOf(x2).toEqualTypeOf<
             ValueExpression<
                 number,
-                [From<Arithmetic, number, [Fact<Arithmetic, 'input'>]>, LiteralExpression<2, NumberExpr>],
+                [From<Arithmetic, number, Fact<Arithmetic, 'input'>>, LiteralExpression<2, NumberExpr>],
+                [Fact<Arithmetic, 'input'>],
                 ModExpr
             >
         >()
@@ -507,7 +516,8 @@ describe('mod', () => {
         expectTypeOf(x3).toEqualTypeOf<
             ValueExpression<
                 number,
-                [LiteralExpression<2, NumberExpr>, From<Arithmetic, number, [Fact<Arithmetic, 'input'>]>],
+                [LiteralExpression<2, NumberExpr>, From<Arithmetic, number, Fact<Arithmetic, 'input'>>],
+                [Fact<Arithmetic, 'input'>],
                 ModExpr
             >
         >()
diff --git a/src/expressions/string.spec.ts b/src/expressions/string.spec.ts
index f2d3c5f..4fcdd99 100644
--- a/src/expressions/string.spec.ts
+++ b/src/expressions/string.spec.ts
@@ -97,6 +97,7 @@ describe('concat', () => {
                     // these duplicates are not the nicest
                     ...(LiteralExpression<'1', StringExpr> | LiteralExpression<'2', StringExpr>)[],
                 ],
+                never,
                 ConcatExpr
             >
         >()
@@ -106,11 +107,12 @@ describe('concat', () => {
             ValueExpression<
                 string,
                 [
-                    From<AbObj, string, [Fact<AbObj, 'input'>]>,
+                    From<AbObj, string, Fact<AbObj, 'input'>>,
                     LiteralExpression<'2', StringExpr>,
                     // these duplicates are not the nicest
-                    ...(From<AbObj, string, [Fact<AbObj, 'input'>]> | LiteralExpression<'2', StringExpr>)[],
+                    ...(From<AbObj, string, Fact<AbObj, 'input'>> | LiteralExpression<'2', StringExpr>)[],
                 ],
+                [Fact<AbObj, 'input'>],
                 ConcatExpr
             >
         >()
@@ -121,10 +123,11 @@ describe('concat', () => {
                 string,
                 [
                     LiteralExpression<'2', StringExpr>,
-                    From<AbObj, string, [Fact<AbObj, 'input'>]>,
+                    From<AbObj, string, Fact<AbObj, 'input'>>,
                     // these duplicates are not the nicest
-                    ...(From<AbObj, string, [Fact<AbObj, 'input'>]> | LiteralExpression<'2', StringExpr>)[],
+                    ...(From<AbObj, string, Fact<AbObj, 'input'>> | LiteralExpression<'2', StringExpr>)[],
                 ],
+                [Fact<AbObj, 'input'>],
                 ConcatExpr
             >
         >()
diff --git a/test/policies.spec.ts b/test/policies.spec.ts
index bb791e5..3b2cd9b 100644
--- a/test/policies.spec.ts
+++ b/test/policies.spec.ts
@@ -33,8 +33,9 @@ describe('arbitrary', () => {
 
 describe('any string starts with', () => {
     const inputs = ['foo', 'bar', 'baz']
-    const startedWith: ValueExpression<boolean[], [LiteralExpression<string[], StringArrExpr>], BooleanExpr> = $map(inputs, (x) =>
-        $startsWith(x, 'foo'),
+    const startedWith: ValueExpression<boolean[], [LiteralExpression<string[], StringArrExpr>], never, BooleanExpr> = $map(
+        inputs,
+        (x) => $startsWith(x, 'foo'),
     )
     const startsWithFoo = $policy({ startedWith })