@pikku/core 0.12.15 → 0.12.17

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 ## 0.12.4
 
+## 0.12.17
+
+### Patch Changes
+
+- 854737b: Add `ListInput<F, S>` / `ListOutput<Row>` / `Filter<F>` types for list-function primitives.
+
+  A "list function" is any Pikku function that returns a paginated collection. Adopting this shape unlocks a shared vocabulary across MCP tools, AI agents, typed RPC clients, and widget libraries — they all reason about cursor, filter, sort, and search uniformly.
+
+  These are purely structural constraints; no runtime behaviour change. A list function is still a normal `pikkuFunc` whose input extends `ListInput<F, S>` and output extends `ListOutput<Row>`.
+
+  ```ts
+  import { pikkuFunc } from '#pikku'
+  import type { ListInput, ListOutput } from '@pikku/core'
+
+  export const listSessions = pikkuFunc<
+    ListInput<{ status?: SessionStatus[] }, 'user' | 'status' | 'uploaded_at'>,
+    ListOutput<Session>
+  >({
+    func: async ({ kysely }, input) => {
+      /* ... */
+    },
+  })
+  ```
+
+  `Filter<F>` is a recursive AND/OR tree: arrays are AND of children, objects with label keys are OR of children, single-key objects with a field name from `F` are leaf predicates. Leaf operators mirror Prisma's vocabulary (`equals`, `in`, `notIn`, `gt`, `gte`, `lt`, `lte`, `contains`, `startsWith`, `endsWith`, `not`, `mode`).
+
+  Follow-ups (separate PRs): `applyFilter<DB>(qb, filter)` Kysely helper, `usePikkuListQuery` in the CLI's react-query generator, first-class MCP list-tool shape.
+
+## 0.12.16
+
+### Patch Changes
+
+- fbcf5b9: Add middleware priority system, telemetry middleware, and statusCode getter. Middleware now supports named priority levels (highest, high, medium, low, lowest) that control execution order regardless of registration order. Includes telemetryOuter and telemetryInner middleware for observability instrumentation via structured console.log output. PikkuHTTPResponse now exposes a readonly `statusCode` getter across all response implementations.
+
 ## 0.12.15
 
 ### Patch Changes

package/dist/function/index.d.ts

@@ -1,3 +1,4 @@
 export { addFunction, getAllFunctionNames } from './function-runner.js';
 export { pikkuAuth, pikkuPermission, pikkuPermissionFactory, pikkuApprovalDescription, } from './functions.types.js';
 export type { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission, } from './functions.types.js';
+export type { ListInput, ListOutput, Filter, LeafFilter, LeafValue, } from './list.types.js';

package/dist/function/list.types.d.ts

@@ -0,0 +1,113 @@
+/**
+ * List-function primitives.
+ *
+ * A "list function" is any Pikku function that returns a paginated
+ * collection. Adopting this shape unlocks a shared vocabulary across
+ * MCP tools, AI agents, typed RPC clients, and widget libraries — they
+ * all reason about cursor, filter, sort, and search uniformly.
+ *
+ * Under the hood, a list function is still a normal `pikkuFunc`. These
+ * types are purely structural constraints; no runtime behaviour change.
+ *
+ * @example
+ * ```ts
+ * import { pikkuFunc } from '#pikku'
+ * import type { ListInput, ListOutput } from '@pikku/core'
+ *
+ * export const listSessions = pikkuFunc<
+ *   ListInput<{ status?: SessionStatus[] }, 'user' | 'status' | 'uploaded_at'>,
+ *   ListOutput<Session>
+ * >({
+ *   func: async ({ kysely }, input) => {
+ *     // input.sort / input.filter / input.cursor / input.search are typed
+ *     return { rows, nextCursor, totalCount }
+ *   },
+ * })
+ * ```
+ */
+/**
+ * Shape every list function accepts as input.
+ *
+ * @template F - User-defined filter shape. Each key is a filterable field.
+ * @template S - String union of sortable column names.
+ */
+export interface ListInput<F extends Record<string, unknown> = Record<string, never>, S extends string = never> {
+    /** Opaque cursor from the previous page's `nextCursor`. */
+    cursor?: string;
+    /** Page size. Server may cap. */
+    limit?: number;
+    /** Ordered sort criteria — first entry is primary. */
+    sort?: Array<{
+        column: S;
+        direction: 'asc' | 'desc';
+    }>;
+    /** Structured filter tree. See {@link Filter}. */
+    filter?: Filter<F>;
+    /** Unstructured text search across server-configured fields. */
+    search?: string;
+}
+/**
+ * Shape every list function returns.
+ */
+export interface ListOutput<Row> {
+    rows: Row[];
+    /** Null when no more pages. */
+    nextCursor: string | null;
+    /** Optional — backend may skip when expensive. */
+    totalCount?: number;
+}
+/**
+ * Leaf predicate value on a single field.
+ *
+ * Operator keywords (`equals`, `not`, `in`, `notIn`, `gt`, `gte`, `lt`,
+ * `lte`, `contains`, `startsWith`, `endsWith`, `mode`) mirror Prisma's
+ * vocabulary for dev familiarity. These keys are reserved and cannot be
+ * used as user field names in a Filter's `F` type.
+ */
+export type LeafValue<T> = T | null | T[] | {
+    equals?: T | null;
+    not?: T | null | LeafValue<T>;
+    in?: T[];
+    notIn?: T[];
+    gt?: T;
+    gte?: T;
+    lt?: T;
+    lte?: T;
+    contains?: string;
+    startsWith?: string;
+    endsWith?: string;
+    mode?: 'sensitive' | 'insensitive';
+};
+/**
+ * A single-key object keyed by a field name from F, value is a leaf
+ * predicate. Single-key so the runtime discriminator is unambiguous:
+ * multi-key objects are OR groups.
+ */
+export type LeafFilter<F extends Record<string, unknown>> = {
+    [K in keyof F]: {
+        [Key in K]: LeafValue<F[K]>;
+    };
+}[keyof F];
+/**
+ * Recursive filter tree.
+ *
+ * - `Array<Filter<F>>` — AND of children.
+ * - `{ [label: string]: Filter<F> }` — OR of children. Keys are arbitrary
+ *   labels (unique strings), ignored at evaluation time.
+ * - `LeafFilter<F>` — single-key predicate on a declared field.
+ *
+ * @example "status = pending AND (therapist = kim OR therapist = park) AND uploaded_at > 2026-04-10"
+ * ```ts
+ * const filter: Filter<{ status: string; therapistId: string; uploadedAt: string }> = [
+ *   { status: 'pending' },
+ *   {
+ *     kim:  { therapistId: 'kim' },
+ *     park: { therapistId: 'park' },
+ *   },
+ *   { uploadedAt: { gt: '2026-04-10' } },
+ * ]
+ * ```
+ */
+export type Filter<F extends Record<string, unknown>> = LeafFilter<F> | Filter<F>[] | {
+    [label: string]: Filter<F>;
+};

package/dist/function/list.types.js

@@ -0,0 +1,28 @@
+/**
+ * List-function primitives.
+ *
+ * A "list function" is any Pikku function that returns a paginated
+ * collection. Adopting this shape unlocks a shared vocabulary across
+ * MCP tools, AI agents, typed RPC clients, and widget libraries — they
+ * all reason about cursor, filter, sort, and search uniformly.
+ *
+ * Under the hood, a list function is still a normal `pikkuFunc`. These
+ * types are purely structural constraints; no runtime behaviour change.
+ *
+ * @example
+ * ```ts
+ * import { pikkuFunc } from '#pikku'
+ * import type { ListInput, ListOutput } from '@pikku/core'
+ *
+ * export const listSessions = pikkuFunc<
+ *   ListInput<{ status?: SessionStatus[] }, 'user' | 'status' | 'uploaded_at'>,
+ *   ListOutput<Session>
+ * >({
+ *   func: async ({ kysely }, input) => {
+ *     // input.sort / input.filter / input.cursor / input.search are typed
+ *     return { rows, nextCursor, totalCount }
+ *   },
+ * })
+ * ```
+ */
+export {};

package/dist/index.d.ts

@@ -1,11 +1,12 @@
 /**
  * @module @pikku/core
  */
-export type { CommonWireMeta, CoreConfig, CorePikkuMiddleware, CorePikkuMiddlewareConfig, CorePikkuMiddlewareFactory, CorePikkuMiddlewareGroup, CoreServices, CoreSingletonServices, CoreUserSession, CreateConfig, FunctionMeta, FunctionRuntimeMeta, FunctionServicesMeta, FunctionWiresMeta, FunctionsMeta, FunctionsRuntimeMeta, JSONPrimitive, JSONValue, MakeRequired, MiddlewareMetadata, PermissionMetadata, PickOptional, PickRequired, PikkuAIMiddlewareHooks, PikkuWire, PikkuWiringTypes, RequireAtLeastOne, SerializedError, WireServices, } from './types/core.types.js';
+export type { CommonWireMeta, CoreConfig, CorePikkuMiddleware, CorePikkuMiddlewareConfig, CorePikkuMiddlewareFactory, CorePikkuMiddlewareGroup, CoreServices, CoreSingletonServices, CoreUserSession, CreateConfig, FunctionMeta, FunctionRuntimeMeta, FunctionServicesMeta, FunctionWiresMeta, FunctionsMeta, FunctionsRuntimeMeta, JSONPrimitive, JSONValue, MakeRequired, MiddlewareMetadata, MiddlewarePriority, PermissionMetadata, PickOptional, PickRequired, PikkuAIMiddlewareHooks, PikkuWire, PikkuWiringTypes, RequireAtLeastOne, SerializedError, WireServices, } from './types/core.types.js';
 export { pikkuAIMiddleware, pikkuChannelMiddleware, pikkuChannelMiddlewareFactory, pikkuMiddleware, pikkuMiddlewareFactory, } from './types/core.types.js';
 export type { CorePikkuAuth, CorePikkuAuthConfig, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuPermissionConfig, CorePikkuPermissionFactory, CorePikkuApprovalDescription, CorePermissionGroup, ZodLike, } from './function/functions.types.js';
 export { pikkuAuth, pikkuPermission, pikkuPermissionFactory, pikkuApprovalDescription, } from './function/functions.types.js';
 export { addFunction, getAllFunctionNames } from './function/index.js';
+export type { ListInput, ListOutput, Filter, LeafFilter, LeafValue, } from './function/list.types.js';
 export { PikkuRequest } from './pikku-request.js';
 export { getRelativeTimeOffsetFromNow, parseDurationString, } from './time-utils.js';
 export type { RelativeTimeInput } from './time-utils.js';

package/dist/middleware/index.d.ts

@@ -3,5 +3,6 @@ export { authCookie } from './auth-cookie.js';
 export { authBearer } from './auth-bearer.js';
 export { pikkuRemoteAuthMiddleware } from './remote-auth.js';
 export { cors } from './cors.js';
+export { telemetryOuter, telemetryInner } from './telemetry.js';
 export { addMiddleware, runMiddleware } from '../middleware-runner.js';
 export { addPermission } from '../permissions.js';

package/dist/middleware/index.js

@@ -3,5 +3,6 @@ export { authCookie } from './auth-cookie.js';
 export { authBearer } from './auth-bearer.js';
 export { pikkuRemoteAuthMiddleware } from './remote-auth.js';
 export { cors } from './cors.js';
+export { telemetryOuter, telemetryInner } from './telemetry.js';
 export { addMiddleware, runMiddleware } from '../middleware-runner.js';
 export { addPermission } from '../permissions.js';

package/dist/middleware/telemetry.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Outer telemetry middleware that captures total request duration and outcome.
+ * Runs at `highest` priority (outermost in the middleware chain).
+ *
+ * Emits a structured JSON log entry with `__pikku_telemetry: 'end'` containing:
+ * - Total duration (including all middleware)
+ * - Outcome (ok/error)
+ * - Wire metadata (wireType, wireId, traceId)
+ * - HTTP details (method, path, status) if applicable
+ *
+ * @example
+ * ```typescript
+ * import { telemetryOuter } from '@pikku/core/middleware'
+ * addMiddleware('myTag', [telemetryOuter()])
+ * ```
+ */
+export declare const telemetryOuter: import("../types/core.types.js").CorePikkuMiddlewareFactory<void | {
+    environmentId?: string;
+    orgId?: string;
+}, import("../types/core.types.js").CoreSingletonServices<{
+    logLevel?: import("../services/logger.js").LogLevel;
+    secrets?: {};
+    workflow?: import("../wirings/workflow/workflow.types.js").WorkflowServiceConfig;
+}>, import("../types/core.types.js").CoreUserSession>;
+/**
+ * Inner telemetry middleware that captures function execution duration and user context.
+ * Runs at `lowest` priority (innermost, closest to the function).
+ *
+ * Emits a structured JSON log entry with `__pikku_telemetry: 'end'` containing:
+ * - Function-only duration (excluding outer middleware like auth)
+ * - User identity (pikkuUserId) if authenticated
+ * - Wire metadata (wireType, wireId, traceId)
+ *
+ * @example
+ * ```typescript
+ * import { telemetryInner } from '@pikku/core/middleware'
+ * addMiddleware('myTag', [telemetryInner()])
+ * ```
+ */
+export declare const telemetryInner: import("../types/core.types.js").CorePikkuMiddlewareFactory<void | {
+    environmentId?: string;
+    orgId?: string;
+}, import("../types/core.types.js").CoreSingletonServices<{
+    logLevel?: import("../services/logger.js").LogLevel;
+    secrets?: {};
+    workflow?: import("../wirings/workflow/workflow.types.js").WorkflowServiceConfig;
+}>, import("../types/core.types.js").CoreUserSession>;

package/dist/middleware/telemetry.js

@@ -0,0 +1,106 @@
+import { pikkuMiddleware, pikkuMiddlewareFactory } from '../types/core.types.js';
+/**
+ * Outer telemetry middleware that captures total request duration and outcome.
+ * Runs at `highest` priority (outermost in the middleware chain).
+ *
+ * Emits a structured JSON log entry with `__pikku_telemetry: 'end'` containing:
+ * - Total duration (including all middleware)
+ * - Outcome (ok/error)
+ * - Wire metadata (wireType, wireId, traceId)
+ * - HTTP details (method, path, status) if applicable
+ *
+ * @example
+ * ```typescript
+ * import { telemetryOuter } from '@pikku/core/middleware'
+ * addMiddleware('myTag', [telemetryOuter()])
+ * ```
+ */
+export const telemetryOuter = pikkuMiddlewareFactory(({ environmentId, orgId } = {}) => {
+    return pikkuMiddleware({
+        name: 'telemetry-outer',
+        priority: 'highest',
+        func: async (services, wire, next) => {
+            const start = performance.now();
+            let outcome = 'ok';
+            let errorMessage;
+            try {
+                await next();
+            }
+            catch (e) {
+                outcome = 'error';
+                errorMessage = e instanceof Error ? e.message : String(e);
+                throw e;
+            }
+            finally {
+                services.logger.info({
+                    __pikku_telemetry: 'end',
+                    __pikku_layer: 'outer',
+                    traceId: wire.traceId,
+                    wireType: wire.wireType,
+                    wireId: wire.wireId,
+                    totalDuration: Math.round(performance.now() - start),
+                    outcome,
+                    ...(errorMessage ? { errorMessage } : {}),
+                    ...(wire.http
+                        ? {
+                            httpStatus: wire.http.response?.statusCode,
+                            httpMethod: wire.http.request?.method(),
+                            httpPath: wire.http.request?.path(),
+                        }
+                        : {}),
+                    ...(environmentId ? { environmentId } : {}),
+                    ...(orgId ? { orgId } : {}),
+                });
+            }
+        },
+    });
+});
+/**
+ * Inner telemetry middleware that captures function execution duration and user context.
+ * Runs at `lowest` priority (innermost, closest to the function).
+ *
+ * Emits a structured JSON log entry with `__pikku_telemetry: 'end'` containing:
+ * - Function-only duration (excluding outer middleware like auth)
+ * - User identity (pikkuUserId) if authenticated
+ * - Wire metadata (wireType, wireId, traceId)
+ *
+ * @example
+ * ```typescript
+ * import { telemetryInner } from '@pikku/core/middleware'
+ * addMiddleware('myTag', [telemetryInner()])
+ * ```
+ */
+export const telemetryInner = pikkuMiddlewareFactory(({ environmentId, orgId } = {}) => {
+    return pikkuMiddleware({
+        name: 'telemetry-inner',
+        priority: 'lowest',
+        func: async (services, wire, next) => {
+            const start = performance.now();
+            let outcome = 'ok';
+            let errorMessage;
+            try {
+                await next();
+            }
+            catch (e) {
+                outcome = 'error';
+                errorMessage = e instanceof Error ? e.message : String(e);
+                throw e;
+            }
+            finally {
+                services.logger.info({
+                    __pikku_telemetry: 'end',
+                    __pikku_layer: 'inner',
+                    traceId: wire.traceId,
+                    wireType: wire.wireType,
+                    wireId: wire.wireId,
+                    functionDuration: Math.round(performance.now() - start),
+                    outcome,
+                    pikkuUserId: wire.pikkuUserId,
+                    ...(errorMessage ? { errorMessage } : {}),
+                    ...(environmentId ? { environmentId } : {}),
+                    ...(orgId ? { orgId } : {}),
+                });
+            }
+        },
+    });
+});

package/dist/middleware-runner.js

@@ -1,5 +1,19 @@
 import { pikkuState } from './pikku-state.js';
 import { freezeDedupe, getTagGroups } from './utils.js';
+const PRIORITY_ORDER = {
+    highest: 0,
+    high: 1,
+    medium: 2,
+    low: 3,
+    lowest: 4,
+};
+const getMiddlewarePriority = (fn) => {
+    const priority = fn.__priority;
+    return PRIORITY_ORDER[priority ?? 'medium'];
+};
+const sortByPriority = (middlewares) => {
+    return middlewares.sort((a, b) => getMiddlewarePriority(a) - getMiddlewarePriority(b));
+};
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
  *
@@ -18,11 +32,14 @@ import { freezeDedupe, getTagGroups } from './utils.js';
  * );
  */
 export const runMiddleware = async (services, wire, middlewares, main) => {
-    // Deduplicate middleware using Set to avoid running the same middleware multiple times
+    // Sort by priority if not already sorted (cached middleware is pre-sorted)
+    const sorted = isSortedByPriority(middlewares)
+        ? middlewares
+        : [...middlewares].sort((a, b) => getMiddlewarePriority(a) - getMiddlewarePriority(b));
     let result;
     const dispatch = async (index) => {
-        if (middlewares && index < middlewares.length) {
-            return await middlewares[index](services, wire, () => dispatch(index + 1));
+        if (sorted && index < sorted.length) {
+            return await sorted[index](services, wire, () => dispatch(index + 1));
         }
         else if (main) {
             result = await main();
@@ -31,6 +48,15 @@ export const runMiddleware = async (services, wire, middlewares, main) => {
     await dispatch(0);
     return result;
 };
+const isSortedByPriority = (middlewares) => {
+    for (let i = 1; i < middlewares.length; i++) {
+        if (getMiddlewarePriority(middlewares[i]) <
+            getMiddlewarePriority(middlewares[i - 1])) {
+            return false;
+        }
+    }
+    return true;
+};
 /**
  * Registers global middleware for a specific tag.
  *
@@ -176,7 +202,8 @@ export const combineMiddleware = (wireType, uid, { wireInheritedMiddleware, wire
     if (funcMiddleware) {
         resolved.push(...funcMiddleware);
     }
-    // Deduplicate and freeze
+    // Sort by priority, deduplicate, and freeze
+    sortByPriority(resolved);
     middlewareCache[wireType][uid] = freezeDedupe(resolved);
     return middlewareCache[wireType][uid];
 };

package/dist/types/core.types.d.ts

@@ -224,6 +224,17 @@ export type PikkuWire<In = unknown, Out = unknown, HasInitialSession extends boo
  * A function that can wrap an wire and be called before or after
  */
 export type CorePikkuMiddleware<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices, wires: PikkuWire<unknown, unknown, false, UserSession>, next: () => Promise<void>) => Promise<void>;
+/**
+ * Priority levels for middleware execution order.
+ * Lower priority runs first (outermost in the onion model).
+ *
+ * - `highest` — Runs first (outermost). Use for telemetry, request tracing.
+ * - `high` — Runs early. Use for CORS, rate limiting.
+ * - `medium` — Default. Use for auth, most user middleware.
+ * - `low` — Runs late. Use for post-auth processing.
+ * - `lowest` — Runs last (innermost, closest to function). Use for inner telemetry.
+ */
+export type MiddlewarePriority = 'highest' | 'high' | 'medium' | 'low' | 'lowest';
 /**
  * Configuration object for creating middleware with metadata
  *
@@ -237,6 +248,8 @@ export type CorePikkuMiddlewareConfig<SingletonServices extends CoreSingletonSer
     name?: string;
     /** Optional description of what the middleware does */
     description?: string;
+    /** Execution priority. Lower runs first (outermost). Defaults to 'medium'. */
+    priority?: MiddlewarePriority;
 };
 /**
  * A factory function that takes input and returns middleware

package/dist/types/core.types.js

@@ -24,7 +24,13 @@
  * ```
  */
 export const pikkuMiddleware = (middleware) => {
-    return typeof middleware === 'function' ? middleware : middleware.func;
+    if (typeof middleware === 'function')
+        return middleware;
+    const func = middleware.func;
+    if (middleware.priority) {
+        func.__priority = middleware.priority;
+    }
+    return func;
 };
 /**
  * Factory function for creating middleware factories

package/dist/wirings/cli/cli-runner.js

@@ -323,8 +323,9 @@ export async function executeCLI({ programName, args, createConfig, createSingle
         const config = createConfig
             ? await createConfig(new LocalVariablesService(), data)
             : {};
-        // Create services with config
+        // Create services with config and register in global state
         const singletonServices = await createSingletonServices(config);
+        pikkuState(null, 'package', 'singletonServices', singletonServices);
         // Execute the command
         await runCLICommand({
             program: programName,

package/dist/wirings/http/http.types.d.ts

@@ -167,6 +167,7 @@ export interface PikkuHTTPRequest<In = unknown> {
     query(): PikkuQuery;
 }
 export interface PikkuHTTPResponse<Out = unknown> {
+    readonly statusCode: number;
     status(code: number): this;
     cookie(name: string, value: string | null, options: SerializeOptions): this;
     header(name: string, value: string | string[]): this;

package/dist/wirings/http/pikku-fetch-http-response.d.ts

@@ -3,6 +3,7 @@ import type { SerializeOptions as CookieSerializeOptions } from 'cookie';
 export declare class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
     #private;
     setMode(mode: 'stream'): void;
+    get statusCode(): number;
     status(code: number): this;
     cookie(name: string, value: string, flags: CookieSerializeOptions): this;
     header(name: string, value: string | string[]): this;

package/dist/wirings/http/pikku-fetch-http-response.js

@@ -13,6 +13,9 @@ export class PikkuFetchHTTPResponse {
             this.#body = this.createStream();
         }
     }
+    get statusCode() {
+        return this.#statusCode;
+    }
     status(code) {
         this.#statusCode = code;
         return this;

package/dist/wirings/mcp/mcp.types.d.ts

@@ -80,7 +80,7 @@ export type CoreMCPResource<PikkuFunctionConfig = CorePikkuFunctionConfig<CorePi
 export type CoreMCPTool<PikkuFunctionConfig = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>>, PikkuPermission = CorePikkuPermission<any, any>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
     name: string;
     title?: string;
-    description: string;
+    description?: string;
     summary?: string;
     errors?: string[];
     func: PikkuFunctionConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.12.15",
+  "version": "0.12.17",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",

package/src/function/index.ts

@@ -13,3 +13,10 @@ export type {
   CorePikkuAuthConfig,
   CorePikkuPermission,
 } from './functions.types.js'
+export type {
+  ListInput,
+  ListOutput,
+  Filter,
+  LeafFilter,
+  LeafValue,
+} from './list.types.js'