drizzle-cube 0.5.8 → 0.6.1

package/dist/server/physical-plan/drizzle-plan-builder.d.ts

@@ -0,0 +1,50 @@
+import { DatabaseAdapter } from '../adapters/base-adapter.js';
+import { DrizzleSqlBuilder } from './drizzle-sql-builder.js';
+import { CTEBuilder } from '../builders/cte-builder.js';
+import { PhysicalQueryPlan, QueryContext, SemanticQuery } from '../types/index.js';
+import { QueryNode } from '../logical-plan/index.js';
+/**
+ * Converts optimised logical plans into runtime physical query plans,
+ * then builds executable Drizzle queries.
+ */
+export declare class DrizzlePlanBuilder {
+    private readonly queryBuilder;
+    private readonly cteBuilder;
+    private readonly databaseAdapter;
+    constructor(queryBuilder: DrizzleSqlBuilder, cteBuilder: CTEBuilder, databaseAdapter: DatabaseAdapter);
+    /**
+     * Build runtime physical context from an optimised logical plan.
+     * This is the physical-builder input for SQL generation.
+     */
+    derivePhysicalPlanContext(plan: QueryNode): PhysicalQueryPlan;
+    /**
+     * Materialize a symbolic JoinRef into a runtime JoinCubePlanEntry, building
+     * the Drizzle join condition(s) from the join definition. This is the seam
+     * where the logical plan's symbolic join refs become executable SQL — the
+     * planner no longer pre-builds any join SQL.
+     *
+     * Junction-table security is NOT materialized here: the stored
+     * `through.securitySql` function is carried forward and applied (in the WHERE
+     * clause) at build time with the request's security context.
+     */
+    private materializeJoin;
+    private derivePhysicalPlanContextFromMultiFact;
+    private derivePhysicalPlanContextFromFullKeyAggregate;
+    /**
+     * Reconstruct a SemanticQuery from a (possibly optimised) QueryNode.
+     *
+     * This is the materialization seam that makes the logical plan a real IR:
+     * the executor derives the query the physical builder consumes from the
+     * optimised plan, so optimiser rewrites of measures/filters/limit/etc. take
+     * effect in the generated SQL. Must faithfully round-trip every field the
+     * physical builder and processors read off a SemanticQuery.
+     */
+    toSemanticQuery(node: QueryNode): SemanticQuery;
+    private resolvePhysicalSimpleSource;
+    private resolvePhysicalSimpleSourceFromKeysDedup;
+    private resolveKeysDeduplicationMeta;
+    /**
+     * Build unified query that works for both single and multi-cube queries.
+     */
+    build(queryPlan: PhysicalQueryPlan, query: SemanticQuery, context: QueryContext): any;
+}

package/dist/server/{server/physical-plan → physical-plan}/drizzle-sql-builder.d.ts

@@ -1,7 +1,7 @@
 import { SQL, AnyColumn } from 'drizzle-orm';
-import { SemanticQuery, FilterOperator, Filter, Cube, QueryContext, PhysicalQueryPlan } from '../types';
-import { DatabaseAdapter } from '../adapters/base-adapter';
-import { ResolvedMeasures } from '../template-substitution';
+import { SemanticQuery, FilterOperator, Filter, Cube, QueryContext, PhysicalQueryPlan } from '../types/index.js';
+import { DatabaseAdapter } from '../adapters/base-adapter.js';
+import { ResolvedMeasures } from '../template-substitution.js';
 export declare class DrizzleSqlBuilder {
     private dateTimeBuilder;
     private filterBuilder;
@@ -54,6 +54,15 @@ export declare class DrizzleSqlBuilder {
      * @param preBuiltFilters - Optional map of cube name to pre-built filter SQL for parameter deduplication
      */
     buildWhereConditions(cubes: Map<string, Cube> | Cube, query: SemanticQuery, context: QueryContext, queryPlan?: PhysicalQueryPlan, preBuiltFilters?: Map<string, SQL[]>): SQL[];
+    /**
+     * Append a single regular filter's WHERE condition, preferring pre-built
+     * filter SQL (for parameter deduplication) and skipping CTE-handled cubes.
+     */
+    private appendWhereFilter;
+    /** Append a time dimension's date-range WHERE condition (cached when possible). */
+    private appendTimeDimensionWhere;
+    /** Whether a cube is materialized in a pre-aggregation CTE of the plan. */
+    private cubeIsInCTE;
     /**
      * Build HAVING conditions from semantic query filters (measures only)
      * Works for both single and multi-cube queries
@@ -64,6 +73,8 @@ export declare class DrizzleSqlBuilder {
      * @param filterType - 'where' for dimension filters, 'having' for measure filters
      */
     private processFilter;
+    /** Build a WHERE condition for a dimension filter, honouring CTE skips and the filter cache. */
+    private processWhereDimensionFilter;
     /**
      * Build filter condition using Drizzle operators
      * Delegates to FilterBuilder

package/dist/server/physical-plan/index.d.ts

@@ -0,0 +1,2 @@
+export { DrizzlePlanBuilder } from './drizzle-plan-builder.js';
+export { DrizzleSqlBuilder } from './drizzle-sql-builder.js';

package/dist/server/{server/physical-plan → physical-plan}/processors/cte-processor.d.ts

@@ -1,5 +1,5 @@
-import { PhysicalQueryPlan, QueryContext, SemanticQuery } from '../../types';
-import { PhysicalBuildDependencies, CTEBuildState } from './shared';
+import { PhysicalQueryPlan, QueryContext, SemanticQuery } from '../../types/index.js';
+import { PhysicalBuildDependencies, CTEBuildState } from './shared.js';
 /**
  * Builds pre-aggregation CTE state used by selection/join/predicate processors.
  */

package/dist/server/physical-plan/processors/index.d.ts

@@ -0,0 +1,8 @@
+export { buildCTEState } from './cte-processor.js';
+export { buildModifiedSelections } from './selection-processor.js';
+export { applyJoins } from './joins-processor.js';
+export { applyPredicatesAndFinalize } from './predicates-processor.js';
+export { buildKeysDeduplicationQuery } from './keys-dedup-processor.js';
+export { buildMultiFactMergeQuery } from './multi-fact-processor.js';
+export type { PhysicalBuildDependencies, CTEBuildState, JoinBuildState, SelectionMap, DownstreamJoinState } from './shared.js';
+export { getCubesFromPlan } from './shared.js';

package/dist/server/{server/physical-plan → physical-plan}/processors/joins-processor.d.ts

@@ -1,5 +1,5 @@
-import { Cube, PhysicalQueryPlan, QueryContext } from '../../types';
-import { CTEBuildState, JoinBuildState, PhysicalBuildDependencies, SelectionMap } from './shared';
+import { Cube, PhysicalQueryPlan, QueryContext } from '../../types/index.js';
+import { CTEBuildState, JoinBuildState, PhysicalBuildDependencies, SelectionMap } from './shared.js';
 /**
  * Applies CTEs and JOIN graph construction to the query builder.
  */

package/dist/server/physical-plan/processors/keys-dedup-processor.d.ts

@@ -0,0 +1,13 @@
+import { PhysicalQueryPlan, QueryContext, SemanticQuery } from '../../types/index.js';
+import { PhysicalBuildDependencies } from './shared.js';
+/**
+ * Build the dual-CTE keys-deduplication query, or return null when the plan
+ * does not qualify (caller falls back to the standard build).
+ *
+ * The query splits into:
+ *  - a "keys" CTE that groups by the query grain + multiplied cube primary key
+ *    (pre-aggregating regular measures), and
+ *  - a "pk_agg" CTE that pre-aggregates the multiplied cube's measures per PK,
+ * then re-aggregates both in an outer query joined on the primary key.
+ */
+export declare function buildKeysDeduplicationQuery(queryPlan: PhysicalQueryPlan, query: SemanticQuery, context: QueryContext, deps: PhysicalBuildDependencies): any | null;

package/dist/server/physical-plan/processors/multi-fact-processor.d.ts

@@ -0,0 +1,13 @@
+import { PhysicalQueryPlan, QueryContext, SemanticQuery } from '../../types/index.js';
+import { PhysicalBuildDependencies } from './shared.js';
+/**
+ * Build a function for `build()` so each group CTE can be materialized through
+ * the standard physical-plan builder without a class dependency.
+ */
+export type GroupQueryBuilder = (queryPlan: PhysicalQueryPlan, query: SemanticQuery, context: QueryContext) => any;
+/**
+ * Build a multi-fact-merge query (joining independent measure groups on shared
+ * grain keys), or return null when the plan does not qualify. Falls back to a
+ * UNION-of-keys strategy when a FULL OUTER JOIN is requested but unsupported.
+ */
+export declare function buildMultiFactMergeQuery(queryPlan: PhysicalQueryPlan, query: SemanticQuery, context: QueryContext, deps: PhysicalBuildDependencies, buildGroup: GroupQueryBuilder): any | null;

package/dist/server/{server/physical-plan → physical-plan}/processors/predicates-processor.d.ts

@@ -1,5 +1,5 @@
-import { Cube, PhysicalQueryPlan, QueryContext, SemanticQuery } from '../../types';
-import { CTEBuildState, JoinBuildState, PhysicalBuildDependencies } from './shared';
+import { Cube, PhysicalQueryPlan, QueryContext, SemanticQuery } from '../../types/index.js';
+import { CTEBuildState, JoinBuildState, PhysicalBuildDependencies } from './shared.js';
 /**
  * Applies WHERE/GROUP/HAVING/ORDER/LIMIT phases.
  */

package/dist/server/{server/physical-plan → physical-plan}/processors/selection-processor.d.ts

@@ -1,5 +1,5 @@
-import { Cube, PhysicalQueryPlan, QueryContext, SemanticQuery } from '../../types';
-import { PhysicalBuildDependencies, SelectionMap } from './shared';
+import { Cube, PhysicalQueryPlan, QueryContext, SemanticQuery } from '../../types/index.js';
+import { PhysicalBuildDependencies, SelectionMap } from './shared.js';
 /**
  * Builds and rewrites selections (including CTE and window handling).
  */

package/dist/server/{server/physical-plan → physical-plan}/processors/shared.d.ts

@@ -1,8 +1,8 @@
 import { SQL } from 'drizzle-orm';
-import { DatabaseAdapter } from '../../adapters/base-adapter';
-import { DrizzleSqlBuilder } from '../drizzle-sql-builder';
-import { CTEBuilder } from '../../builders/cte-builder';
-import { Cube, PhysicalQueryPlan } from '../../types';
+import { DatabaseAdapter } from '../../adapters/base-adapter.js';
+import { DrizzleSqlBuilder } from '../drizzle-sql-builder.js';
+import { CTEBuilder } from '../../builders/cte-builder.js';
+import { Cube, PhysicalQueryPlan } from '../../types/index.js';
 export interface PhysicalBuildDependencies {
     queryBuilder: DrizzleSqlBuilder;
     cteBuilder: CTEBuilder;
@@ -30,4 +30,9 @@ export interface JoinBuildState {
     absorbedIntermediateCubes: Set<string>;
 }
 export type SelectionMap = Record<string, any>;
+/**
+ * Apply a join of the given type to a Drizzle query builder.
+ * Shared by the physical-plan builders that assemble CTE/merge queries.
+ */
+export declare function applyJoinByType(drizzleQuery: any, joinType: 'inner' | 'left' | 'right' | 'full', joinTarget: any, joinCondition: SQL): any;
 export declare function getCubesFromPlan(queryPlan: PhysicalQueryPlan): Map<string, Cube>;

package/dist/server/{server/physical-plan → physical-plan}/processors/window-processor.d.ts

@@ -1,5 +1,5 @@
-import { Cube, PhysicalQueryPlan, QueryContext, SemanticQuery } from '../../types';
-import { PhysicalBuildDependencies, SelectionMap } from './shared';
+import { Cube, PhysicalQueryPlan, QueryContext, SemanticQuery } from '../../types/index.js';
+import { PhysicalBuildDependencies, SelectionMap } from './shared.js';
 /**
  * Applies post-aggregation window measures to the selection map.
  */

package/dist/server/query-handlers.d.ts

@@ -0,0 +1,79 @@
+import { SemanticLayerCompiler } from './compiler.js';
+import { SemanticQuery, SecurityContext } from './types/index.js';
+import { CubeDiscoveryResult } from './ai/discovery.js';
+/**
+ * Discovery request body
+ */
+export interface DiscoverRequest {
+    /** Topic or keyword to search for */
+    topic?: string;
+    /** Natural language intent */
+    intent?: string;
+    /** Maximum results to return */
+    limit?: number;
+    /** Minimum relevance score (0-1) */
+    minScore?: number;
+}
+/**
+ * Load request body - execute a query
+ */
+export interface LoadRequest {
+    /** Query to execute */
+    query: SemanticQuery;
+}
+/**
+ * Discovery response shape returned by `handleDiscover`.
+ *
+ * In addition to the matched cubes, the response embeds the full query
+ * language reference and the date filtering decision tree. This is the
+ * primary delivery mechanism for query-construction guidance: clients
+ * cannot be relied upon to forward `prompts/*` content to the model, so
+ * we piggyback on `discover` (the mandated first call in our workflow)
+ * to guarantee the model sees the rules before it builds a query.
+ *
+ * The fields are stable strings — consumers may render or strip them as
+ * they see fit, but the MCP `discover` tool relies on them being present.
+ */
+export interface DiscoverResponse {
+    /** Matched cubes (possibly empty) with measures, dimensions, and joins */
+    cubes: CubeDiscoveryResult[];
+    /**
+     * Complete TypeScript DSL reference for query construction. Source of
+     * truth for field naming, filter operators, time dimensions, and
+     * analysis modes (funnel/flow/retention).
+     */
+    queryLanguageReference: string;
+    /**
+     * Decision tree for date filtering vs time grouping. The single most
+     * common source of incorrect queries — read this whenever the user
+     * mentions a time period.
+     */
+    dateFilteringGuide: string;
+}
+/**
+ * Handle /discover endpoint - find relevant cubes based on topic/intent.
+ *
+ * Always returns `queryLanguageReference` and `dateFilteringGuide` alongside
+ * the matched cubes. See `DiscoverResponse` for the rationale.
+ */
+export declare function handleDiscover(semanticLayer: SemanticLayerCompiler, body: DiscoverRequest): Promise<DiscoverResponse>;
+/**
+ * Normalize AI-generated query fields before validation/execution.
+ * Fixes common LLM mistakes:
+ * - Double-prefixed fields: "Teams.Teams.name" -> "Teams.name"
+ * - Order as array: [{key: dir}] -> {key: dir}
+ * - Underscore order keys: "Teams_count" -> "Teams.count"
+ * - Invalid order keys dropped (falls back to first measure desc)
+ *
+ * This runs in the shared handleLoad path so both MCP and Agent benefit.
+ */
+export declare function normalizeQueryFields(query: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Handle /load endpoint - execute a query and return results
+ * This completes the AI workflow: discover → suggest → validate → load
+ */
+export declare function handleLoad(semanticLayer: SemanticLayerCompiler, securityContext: SecurityContext, body: LoadRequest): Promise<{
+    data: Record<string, unknown>[];
+    annotation: any;
+    query: SemanticQuery;
+}>;

package/dist/server/query-modes.d.ts

@@ -0,0 +1,28 @@
+import { SemanticQuery } from './types/index.js';
+export type QueryMode = 'regular' | 'comparison' | 'funnel' | 'flow' | 'retention';
+export interface QueryModeFlags {
+    comparison: boolean;
+    funnel: boolean;
+    flow: boolean;
+    retention: boolean;
+}
+/** A query is a comparison when a time dimension carries a compareDateRange with ≥2 ranges. */
+export declare function hasComparisonMode(query: SemanticQuery): boolean;
+/**
+ * A query is a funnel when it has a funnel config with ≥2 steps.
+ * Null-safe on `steps` — a `funnel: {}` payload must not throw here.
+ */
+export declare function hasFunnelMode(query: SemanticQuery): boolean;
+/** A query is a flow when it has a flow config with a startingStep and eventDimension. */
+export declare function hasFlowMode(query: SemanticQuery): boolean;
+/** A query is a retention when it has a retention config with a timeDimension and bindingKey. */
+export declare function hasRetentionMode(query: SemanticQuery): boolean;
+/** Per-mode booleans for a query. */
+export declare function detectQueryModes(query: SemanticQuery): QueryModeFlags;
+/**
+ * Active non-regular modes for a query, in execution-priority order
+ * (comparison, funnel, flow, retention). A well-formed query matches at most one.
+ */
+export declare function getActiveQueryModes(query: SemanticQuery): Exclude<QueryMode, 'regular'>[];
+/** The single priority mode for a query, or 'regular' when none match. */
+export declare function detectQueryMode(query: SemanticQuery): QueryMode;

package/dist/server/query-validator.d.ts

@@ -0,0 +1,9 @@
+import { SemanticQuery, Cube } from './types/index.js';
+/**
+ * Validate a query against a cubes map
+ * Standalone function that can be used by both compiler and executor
+ */
+export declare function validateQueryAgainstCubes(cubes: Map<string, Cube>, query: SemanticQuery): {
+    isValid: boolean;
+    errors: string[];
+};

package/dist/server/{server/resolvers → resolvers}/calculated-measure-resolver.d.ts

@@ -1,4 +1,4 @@
-import { Cube, Measure } from '../types/cube';
+import { Cube, Measure } from '../types/cube.js';
 /**
  * Dependency information for a calculated measure
  */
@@ -51,6 +51,11 @@ export declare class CalculatedMeasureResolver {
      * @throws Error if circular dependency detected
      */
     topologicalSort(measureNames: string[]): string[];
+    /**
+     * Build a subgraph containing only the requested measures, with in-degrees
+     * recomputed to count only dependencies that are within the subgraph.
+     */
+    private buildSubgraph;
     /**
      * Detect circular dependencies using DFS
      * Returns the cycle path if found, null otherwise

package/dist/server/{server/resolvers → resolvers}/index.d.ts

@@ -2,5 +2,5 @@
  * Resolvers Index
  * Re-exports resolver components for modular imports
  */
-export { CalculatedMeasureResolver } from './calculated-measure-resolver';
-export { JoinPathResolver } from './join-path-resolver';
+export { CalculatedMeasureResolver } from './calculated-measure-resolver.js';
+export { JoinPathResolver } from './join-path-resolver.js';

package/dist/server/{server/resolvers → resolvers}/join-path-resolver.d.ts

@@ -1,4 +1,4 @@
-import { Cube, CubeJoin } from '../types';
+import { Cube, CubeJoin } from '../types/index.js';
 import { SQL } from 'drizzle-orm';
 /**
  * Internal representation of a join path step
@@ -78,6 +78,12 @@ export declare class JoinPathResolver {
      * @returns Array of join steps or null if no path exists
      */
     findPath(fromCube: string, toCube: string, alreadyProcessed?: Set<string>): InternalJoinPathStep[] | null;
+    /**
+     * Enumerate the neighbouring cubes reachable from `currentCube` in one hop,
+     * yielding the resulting join step. Forward edges (outgoing joins) come first,
+     * then reverse edges (incoming joins) unless `forwardOnly` is set.
+     */
+    private neighbourSteps;
     /**
      * Find path that prefers going through specified cubes when possible
      * Used when certain cubes have measures in the query - ensures joins go through

package/dist/server/sql-format.d.ts

@@ -0,0 +1,11 @@
+/**
+ * SQL pretty-printing for generated queries.
+ *
+ * Lives in the server layer (rather than adapters/) so that the compiler can
+ * format SQL without importing up into the framework-adapter layer — which
+ * would create an import cycle (compiler → adapters/utils → server).
+ */
+/**
+ * Format SQL string using sql-formatter with appropriate dialect
+ */
+export declare function formatSqlString(sqlString: string, engineType: 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake'): string;

package/dist/server/{server/template-substitution.d.ts → template-substitution.d.ts}

@@ -1,5 +1,5 @@
 import { SQL } from 'drizzle-orm';
-import { Cube, QueryContext } from './types/cube';
+import { Cube, QueryContext } from './types/cube.js';
 /**
  * Resolved measure SQL builders
  * Maps full measure names (e.g., "Cube.measure") to functions that build their SQL

package/dist/server/{server/types → types}/cache.d.ts

@@ -1,4 +1,4 @@
-import { SecurityContext } from './core';
+import { SecurityContext } from './core.js';
 /**
  * Return type for cache get operations
  * Includes value and optional metadata for TTL tracking

package/dist/server/{server/types → types}/cube.d.ts

@@ -1,7 +1,23 @@
 import { SQL, AnyColumn, Table, Subquery, View } from 'drizzle-orm';
-import { SecurityContext, DrizzleDatabase, QueryResult, MeasureType, DimensionType, TimeGranularity } from './core';
-import { SemanticQuery } from './query';
-import { FilterCacheManager } from '../filter-cache';
+import { SecurityContext, DrizzleDatabase, QueryResult, MeasureType, DimensionType, TimeGranularity } from './core.js';
+import { SemanticQuery } from './query.js';
+/**
+ * Filter SQL cache used for parameter deduplication across CTEs and the main
+ * query. Defined here (rather than imported from the runtime filter-cache
+ * module) so the types package has no dependency on runtime modules.
+ * Implemented by `FilterCacheManager`.
+ */
+export interface FilterCache {
+    getOrBuild(key: string, builder: () => SQL | null): SQL | null;
+    has(key: string): boolean;
+    get(key: string): SQL | undefined;
+    preload(entries: Array<{
+        key: string;
+        sql: SQL;
+    }>): void;
+    set(key: string, sql: SQL): void;
+    clear(): void;
+}
 /**
  * Any queryable relation that can be used in FROM/JOIN clauses
  * Supports tables, views, subqueries, and raw SQL expressions
@@ -42,7 +58,7 @@ export interface QueryContext {
      * Filter cache for parameter deduplication across CTEs
      * Created at query start and used throughout query building
      */
-    filterCache?: FilterCacheManager;
+    filterCache?: FilterCache;
     /**
      * When true, measures should be rendered as raw column expressions
      * without aggregation wrappers. Set from SemanticQuery.ungrouped.
@@ -360,7 +376,7 @@ export interface PropagatingFilter {
     /** The source cube whose filters need to propagate */
     sourceCube: Cube;
     /** Filters from the source cube to apply */
-    filters: import('./query').Filter[];
+    filters: import('./query.js').Filter[];
     /** Join conditions linking source cube PK(s) to target cube FK(s) - supports composite keys */
     joinConditions: JoinKeyPair[];
     /** Pre-built filter SQL for parameter deduplication (optional, built during query planning) */
@@ -376,8 +392,6 @@ export interface IntermediateJoinInfo {
     cube: Cube;
     /** The join definition from the intermediate cube to this CTE cube */
     joinDef: CubeJoin;
-    /** Security filter to apply to the intermediate table within the CTE */
-    securityFilter?: SQL;
     /** The column on the intermediate table that connects to the primary cube */
     primaryJoinColumn: AnyColumn;
     /** The column on the intermediate table that connects to the CTE cube */
@@ -512,7 +526,7 @@ export interface PhysicalQueryPlan {
         }>;
     };
     /** Warnings about potential query issues (e.g., fan-out without dimensions) */
-    warnings?: import('./core').QueryWarning[];
+    warnings?: import('./core.js').QueryWarning[];
 }
 /**
  * Utility type for cube definition with schema inference

package/dist/server/{server/types → types}/executor.d.ts

@@ -1,6 +1,6 @@
 import { SQL } from 'drizzle-orm';
-import { DrizzleDatabase } from './core';
-import { DatabaseAdapter } from '../adapters/base-adapter';
+import { DrizzleDatabase } from './core.js';
+import { DatabaseAdapter } from '../adapters/base-adapter.js';
 /**
  * Database executor interface that wraps Drizzle ORM
  * Provides type-safe SQL execution with engine-specific implementations

package/dist/server/{server/types → types}/flow.d.ts

@@ -1,4 +1,5 @@
-import { Filter } from './query';
+import { Filter } from './query.js';
+import { AnalysisConfigValidationResult } from './validation.js';
 /**
  * Flow query configuration for server-side execution
  * This is the configuration extracted from SemanticQuery.flow
@@ -131,12 +132,12 @@ export interface RawFlowLinkRow {
 }
 /**
  * Flow validation result
+ *
+ * Alias of the shared {@link AnalysisConfigValidationResult} used by all
+ * analysis-mode builders. Kept as a named export for backwards compatibility
+ * with existing consumers.
  */
-export interface FlowValidationResult {
-    isValid: boolean;
-    errors: string[];
-    warnings: string[];
-}
+export type FlowValidationResult = AnalysisConfigValidationResult;
 /** Minimum number of steps before/after */
 export declare const FLOW_MIN_DEPTH = 0;
 /** Maximum number of steps before/after */

package/dist/server/{server/types → types}/funnel.d.ts

@@ -1,4 +1,4 @@
-import { Filter } from './query';
+import { Filter } from './query.js';
 /**
  * Single-cube step definition - all steps use the same cube
  */

package/dist/server/types/index.d.ts

@@ -0,0 +1,11 @@
+export * from './core.js';
+export * from './query.js';
+export * from './funnel.js';
+export * from './retention.js';
+export * from './cube.js';
+export * from './executor.js';
+export * from './metadata.js';
+export * from './analysis.js';
+export * from './validation.js';
+export * from './utils.js';
+export * from './cache.js';

package/dist/server/{server/types → types}/metadata.d.ts

@@ -1,4 +1,4 @@
-import { MeasureType, MeasureFormat, DimensionFormat, TimeGranularity } from './core';
+import { MeasureType, MeasureFormat, DimensionFormat, TimeGranularity } from './core.js';
 /**
  * Cube relationship metadata for ERD visualization
  */

package/dist/server/{server/types → types}/query.d.ts

@@ -1,7 +1,7 @@
-import { TimeGranularity } from './core';
-import { FunnelQueryConfig } from './funnel';
-import { FlowQueryConfig } from './flow';
-import { RetentionQueryConfig } from './retention';
+import { TimeGranularity } from './core.js';
+import { FunnelQueryConfig } from './funnel.js';
+import { FlowQueryConfig } from './flow.js';
+import { RetentionQueryConfig } from './retention.js';
 /**
  * Semantic query structure (Cube.js compatible)
  */

package/dist/server/{server/types → types}/retention.d.ts

@@ -1,4 +1,4 @@
-import { Filter } from './query';
+import { Filter } from './query.js';
 /**
  * Binding key mapping for multi-cube retention
  * Maps the user/entity identifier across cohort and activity cubes

package/dist/server/{server/types → types}/utils.d.ts

@@ -1,5 +1,5 @@
 import { SQL, AnyColumn } from 'drizzle-orm';
-import { QueryContext } from './cube';
+import { QueryContext } from './cube.js';
 /**
  * Type-level utility to extract the schema type from a cube reference
  * Since we removed generics, this now returns 'any'

package/dist/server/types/validation.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared validation types for analysis-mode config validation
+ */
+/**
+ * Result of validating an analysis-mode config (funnel, flow, retention).
+ *
+ * `warnings` is optional — flow analysis surfaces non-fatal warnings, while
+ * funnel and retention only produce errors (and omit the field entirely).
+ */
+export interface AnalysisConfigValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings?: string[];
+}