rawsql-ts 0.26.0 → 0.27.0

package/dist/src/index.d.ts

@@ -77,8 +77,10 @@ export * from './transformers/FilterableItemCollector';
 export { FixtureCteBuilder, FixtureTableDefinition, FixtureColumnDefinition } from './transformers/FixtureCteBuilder';
 export * from './transformers/DynamicQueryBuilder';
 export * from './transformers/SSSQLFilterBuilder';
+export type { FormattableSqlComponent, SqlComponentFormatter, SqlComponentFormatOptions } from './transformers/SqlComponentFormatter';
 export * from './transformers/ConditionOptimization';
 export * from './transformers/ParameterConditionPlacementOptimizer';
+export * from './transformers/StaticPredicatePlacementOptimizer';
 export * from './transformers/PruneOptionalConditionBranches';
 export { SchemaInfo, optimizeUnusedLeftJoins, optimizeUnusedLeftJoinsToFixedPoint, optimizeUnusedCtes, optimizeUnusedCtesToFixedPoint } from './transformers/OptimizeUnusedLeftJoins';
 export * from './transformers/TableColumnResolver';

package/dist/src/transformers/ConditionOptimization.d.ts

@@ -1,8 +1,9 @@
 import { SelectQuery, SimpleSelectQuery } from "../models/SelectQuery";
 import { ParameterConditionMove, ParameterConditionOptimizationError, ParameterConditionOptimizationOptions, ParameterConditionOptimizationWarning, ParameterConditionSkipped } from "./ParameterConditionPlacementOptimizer";
+import { StaticPredicateMove, StaticPredicatePlacementError, StaticPredicatePlacementWarning, StaticPredicateSkipped } from "./StaticPredicatePlacementOptimizer";
 import { OptionalConditionPruningParameters } from "./PruneOptionalConditionBranches";
 export type ConditionOptimizationInput = string | SelectQuery | SimpleSelectQuery;
-export type ConditionOptimizationPhaseKind = "sssql_optional_condition" | "parameter_condition_placement";
+export type ConditionOptimizationPhaseKind = "sssql_optional_condition" | "parameter_condition_placement" | "static_predicate_placement";
 export interface ConditionOptimizationOptions extends ParameterConditionOptimizationOptions {
     /**
      * Explicit opt-in values for SSSQL optional branch pruning.
@@ -36,15 +37,23 @@ export interface SssqlOptionalConditionSkipped {
 }
 export type ConditionOptimizationApplied = SssqlOptionalConditionApplied | (ParameterConditionMove & {
     phaseKind: "parameter_condition_placement";
+}) | (StaticPredicateMove & {
+    phaseKind: "static_predicate_placement";
 });
 export type ConditionOptimizationSkipped = SssqlOptionalConditionSkipped | (ParameterConditionSkipped & {
     phaseKind: "parameter_condition_placement";
+}) | (StaticPredicateSkipped & {
+    phaseKind: "static_predicate_placement";
 });
 export type ConditionOptimizationWarning = (ParameterConditionOptimizationWarning & {
     phaseKind: ConditionOptimizationPhaseKind;
+}) | (StaticPredicatePlacementWarning & {
+    phaseKind: ConditionOptimizationPhaseKind;
 });
 export type ConditionOptimizationError = (ParameterConditionOptimizationError & {
     phaseKind: ConditionOptimizationPhaseKind;
+}) | (StaticPredicatePlacementError & {
+    phaseKind: ConditionOptimizationPhaseKind;
 });
 export interface ConditionOptimizationSafety {
     mode: "safe_only";
@@ -55,6 +64,7 @@ export interface ConditionOptimizationSafety {
 export interface ConditionOptimizationResult {
     ok: boolean;
     sql: string;
+    query: SelectQuery | null;
     phases: readonly ConditionOptimizationPhaseSummary[];
     applied: readonly ConditionOptimizationApplied[];
     skipped: readonly ConditionOptimizationSkipped[];

package/dist/src/transformers/ParameterConditionPlacementOptimizer.d.ts

@@ -1,15 +1,22 @@
 import { SelectQuery, SimpleSelectQuery } from "../models/SelectQuery";
+import { SqlComponentFormatOptions } from "./SqlComponentFormatter";
 export type ParameterConditionOptimizationInput = string | SelectQuery | SimpleSelectQuery;
 /**
  * First-phase safe-only placement for ordinary parameter predicates.
  *
  * The optimizer intentionally handles only root top-level AND predicates and one
  * CTE/derived-table hop where the destination output is a direct column reference.
- * Unsupported boundaries such as OR, UNION, DISTINCT, GROUP BY, WINDOW, OUTER
- * JOIN, expression outputs, and function predicates are reported as skipped.
+ * Unsupported boundaries such as OR, DISTINCT ON, WINDOW, OUTER JOIN,
+ * expression outputs, and function predicates are reported as skipped.
  */
-export interface ParameterConditionOptimizationOptions {
+export interface ParameterConditionOptimizationOptions extends SqlComponentFormatOptions {
     dryRun?: boolean;
+    /**
+     * Whether AST/model inputs should be cloned before optimization.
+     * Defaults to true for public-call safety. Internal pipelines can pass false
+     * when they own the model and want to avoid AST -> SQL -> AST round trips.
+     */
+    cloneInput?: boolean;
 }
 export interface ParameterConditionOptimizationWarning {
     code: string;
@@ -45,6 +52,7 @@ export interface ParameterConditionOptimizationSafety {
 export interface ParameterConditionOptimizationResult {
     ok: boolean;
     sql: string;
+    query: SelectQuery | null;
     applied: readonly ParameterConditionMove[];
     skipped: readonly ParameterConditionSkipped[];
     warnings: readonly ParameterConditionOptimizationWarning[];
@@ -58,21 +66,32 @@ export declare class ParameterConditionPlacementOptimizer {
     private parseInput;
     private analyzeCandidate;
     private findUnsupportedExpression;
+    private findUnsupportedParameterPredicateShape;
     private isSupportedInPredicate;
     private resolveTarget;
-    private findCurrentQueryBoundary;
-    private findTargetQueryBoundary;
+    private findRootQueryBoundary;
+    private resolveTargetPlacement;
     private resolveSourceBinding;
     private resolveUpstreamQuery;
-    private resolveTargetColumn;
+    private resolveUnionTarget;
+    private resolveTargetColumns;
+    private resolveTargetColumnByOutputIndex;
+    private resolveDeepestBranchTarget;
     private verifyColumnResolvableInQuery;
+    private isGroupKeyColumn;
+    private sameResolvableColumnInQuery;
+    private resolveColumnSourceAlias;
     private rebaseCondition;
     private getSourceBindings;
     private findNullableSideBoundary;
     private hasOuterJoin;
+    private hasDistinctOnBoundary;
+    private hasOrdinaryDistinct;
     private getOutputColumnMatchCount;
+    private collectUnionBranches;
+    private resolveUnionOutputIndex;
+    private collectSelectOutputs;
     private resolveSourceQueryForColumns;
-    private getSelectItemOutputName;
     private findCte;
     private countTableSourceReferences;
     private hasWindowUsage;

package/dist/src/transformers/SSSQLFilterBuilder.d.ts

@@ -136,6 +136,12 @@ export declare class SSSQLFilterBuilder {
     private resolveSourceExpressionToUpstreamQuery;
     private resolveAnchorTargetInQuery;
     private getSourceAlias;
+    private buildScalarRefreshPlan;
+    private resolveScalarTargetInQuery;
+    private isNullableBranchColumn;
+    private hasLaterJoinThatNullsPriorSources;
+    private isPriorSourcesNullableJoin;
+    private isJoinedSourceNullable;
     private rebaseMovedBranch;
     private rebaseMovedBranchByAlias;
 }

package/dist/src/transformers/SqlComponentFormatter.d.ts

@@ -0,0 +1,11 @@
+import { SelectQuery, SimpleSelectQuery } from "../models/SelectQuery";
+import { ValueComponent } from "../models/ValueComponent";
+import { SqlFormatterOptions } from "./SqlFormatter";
+export type FormattableSqlComponent = SelectQuery | SimpleSelectQuery | ValueComponent;
+export type SqlComponentFormatter = (component: FormattableSqlComponent) => string;
+export interface SqlComponentFormatOptions {
+    formatter?: SqlComponentFormatter;
+    formatOptions?: SqlFormatterOptions;
+}
+export declare const formatSqlComponent: (component: FormattableSqlComponent, options?: SqlComponentFormatOptions) => string;
+export declare const hasSqlComponentFormatOverride: (options?: SqlComponentFormatOptions) => boolean;

package/dist/src/transformers/StaticPredicatePlacementOptimizer.d.ts

@@ -0,0 +1,103 @@
+import { SelectQuery, SimpleSelectQuery } from "../models/SelectQuery";
+import { SqlComponentFormatOptions } from "./SqlComponentFormatter";
+export type StaticPredicatePlacementInput = string | SelectQuery | SimpleSelectQuery;
+/**
+ * Safe-only placement for parameter-free static predicates.
+ *
+ * The optimizer only moves top-level AND terms whose outer column references can
+ * be mechanically rebased to direct outputs of a single-use simple CTE or
+ * derived table. Unsupported or ambiguous predicates stay in place.
+ */
+export interface StaticPredicatePlacementOptions extends SqlComponentFormatOptions {
+    dryRun?: boolean;
+    /**
+     * Whether AST/model inputs should be cloned before optimization.
+     * Defaults to true for public-call safety. Internal pipelines can pass false
+     * when they own the model and want to avoid AST -> SQL -> AST round trips.
+     */
+    cloneInput?: boolean;
+}
+export interface StaticPredicatePlacementWarning {
+    code: string;
+    message: string;
+    detail?: unknown;
+}
+export interface StaticPredicatePlacementError {
+    code: string;
+    message: string;
+    detail?: unknown;
+}
+export interface StaticPredicateMove {
+    kind: "move_static_predicate";
+    predicateSql: string;
+    fromScopeId: string;
+    toScopeId: string;
+    reason: string;
+    columnReferences: readonly string[];
+}
+export interface StaticPredicateSkipped {
+    predicateSql: string;
+    scopeId: string;
+    reason: string;
+    code: string;
+}
+export interface StaticPredicatePlacementSafety {
+    mode: "safe_only";
+    unsafeRewriteApplied: false;
+    dryRun: boolean;
+    formatterGeneratedSource: boolean;
+}
+export interface StaticPredicatePlacementResult {
+    ok: boolean;
+    sql: string;
+    query: SelectQuery | null;
+    applied: readonly StaticPredicateMove[];
+    skipped: readonly StaticPredicateSkipped[];
+    warnings: readonly StaticPredicatePlacementWarning[];
+    errors: readonly StaticPredicatePlacementError[];
+    safety: StaticPredicatePlacementSafety;
+    staticPredicateMoves: readonly StaticPredicateMove[];
+}
+export declare class StaticPredicatePlacementOptimizer {
+    plan(input: StaticPredicatePlacementInput, options?: StaticPredicatePlacementOptions): StaticPredicatePlacementResult;
+    optimize(input: StaticPredicatePlacementInput, options?: StaticPredicatePlacementOptions): StaticPredicatePlacementResult;
+    private parseInput;
+    private analyzeCandidate;
+    private isExistsPredicate;
+    private findUnsupportedExpression;
+    private resolveTarget;
+    private findRootQueryBoundary;
+    private resolveTargetPlacement;
+    private resolveSourceBinding;
+    private resolveUpstreamQuery;
+    private resolveUnionTarget;
+    private resolveTargetColumns;
+    private resolveDeepestBranchTarget;
+    private verifyColumnResolvableInQuery;
+    private isGroupKeyColumn;
+    private sameResolvableColumnInQuery;
+    private resolveColumnSourceAlias;
+    private rebasePredicate;
+    private getSourceBindings;
+    private findNullableSideBoundary;
+    private hasLaterJoinThatNullsPriorSources;
+    private hasOuterJoin;
+    private hasDistinctOnBoundary;
+    private hasOrdinaryDistinct;
+    private getOutputColumnMatchCount;
+    private collectUnionBranches;
+    private resolveUnionOutputIndex;
+    private resolveTargetColumnByOutputIndex;
+    private collectSelectOutputs;
+    private resolveSourceQueryForColumns;
+    private findCte;
+    private countTableSourceReferences;
+    private collectSourceAliases;
+    private collectRootColumnReferences;
+    private hasWindowUsage;
+    private collectParameterNames;
+    private makeSkipped;
+    private buildResult;
+}
+export declare const planStaticPredicatePlacement: (input: StaticPredicatePlacementInput, options?: StaticPredicatePlacementOptions) => StaticPredicatePlacementResult;
+export declare const optimizeStaticPredicatePlacement: (input: StaticPredicatePlacementInput, options?: StaticPredicatePlacementOptions) => StaticPredicatePlacementResult;

package/dist/transformers/ConditionOptimization.js

@@ -3,19 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.optimizeConditions = exports.planConditionOptimization = void 0;
 const SelectQueryParser_1 = require("../parsers/SelectQueryParser");
 const ParameterConditionPlacementOptimizer_1 = require("./ParameterConditionPlacementOptimizer");
+const StaticPredicatePlacementOptimizer_1 = require("./StaticPredicatePlacementOptimizer");
 const PruneOptionalConditionBranches_1 = require("./PruneOptionalConditionBranches");
 const SSSQLFilterBuilder_1 = require("./SSSQLFilterBuilder");
-const SqlFormatter_1 = require("./SqlFormatter");
-const formatSqlComponent = (component) => {
-    return new SqlFormatter_1.SqlFormatter().format(component).formattedSql;
-};
+const SqlComponentFormatter_1 = require("./SqlComponentFormatter");
 const hasOwnParameter = (parameters, parameterName) => Object.prototype.hasOwnProperty.call(parameters, parameterName);
 const isAbsentOptionalValue = (parameters, parameterName) => parameters[parameterName] === null || parameters[parameterName] === undefined;
-const parseConditionOptimizationInput = (input) => {
+const parseConditionOptimizationInput = (input, options) => {
     const warnings = [];
     const errors = [];
-    const sourceSql = typeof input === "string" ? input : formatSqlComponent(input);
+    const sourceSql = typeof input === "string" ? input : (0, SqlComponentFormatter_1.formatSqlComponent)(input, options);
     const formatterGeneratedSource = typeof input !== "string";
+    if (typeof input !== "string" && options.cloneInput === false) {
+        return {
+            query: input,
+            sql: sourceSql,
+            formatterGeneratedSource: false,
+            warnings,
+            errors
+        };
+    }
     if (formatterGeneratedSource) {
         warnings.push({
             phaseKind: "sssql_optional_condition",
@@ -48,31 +55,31 @@ const parseConditionOptimizationInput = (input) => {
         };
     }
 };
-const buildSssqlApplied = (branch) => {
+const buildSssqlApplied = (branch, options) => {
     return {
         phaseKind: "sssql_optional_condition",
         kind: "prune_optional_branch",
-        conditionSql: formatSqlComponent(branch.expression),
+        conditionSql: (0, SqlComponentFormatter_1.formatSqlComponent)(branch.expression, options),
         parameterName: branch.parameterName,
         reason: "The optional branch parameter is explicitly absent, so the safe-only SSSQL phase pruned the branch."
     };
 };
-const buildSssqlRefreshApplied = (branch, previousConditionSql) => {
+const buildSssqlRefreshApplied = (branch, previousConditionSql, options) => {
     return {
         phaseKind: "sssql_optional_condition",
         kind: "refresh_optional_branch",
-        conditionSql: formatSqlComponent(branch.expression),
+        conditionSql: (0, SqlComponentFormatter_1.formatSqlComponent)(branch.expression, options),
         previousConditionSql,
         parameterName: branch.parameterName,
         reason: "The safe-only SSSQL phase refreshed the optional branch placement before ordinary parameter placement."
     };
 };
-const buildSssqlSkipped = (branch, parameters) => {
+const buildSssqlSkipped = (branch, parameters, options) => {
     const parameterProvided = hasOwnParameter(parameters, branch.parameterName);
     return {
         phaseKind: "sssql_optional_condition",
         kind: "optional_branch_skipped",
-        conditionSql: formatSqlComponent(branch.expression),
+        conditionSql: (0, SqlComponentFormatter_1.formatSqlComponent)(branch.expression, options),
         parameterName: branch.parameterName,
         code: parameterProvided
             ? "SSSQL_OPTIONAL_PARAMETER_PRESENT"
@@ -82,11 +89,11 @@ const buildSssqlSkipped = (branch, parameters) => {
             : "No optional branch parameter value was provided, so the branch remains unchanged."
     };
 };
-const buildSssqlRefreshSkipped = (branch, code, reason) => {
+const buildSssqlRefreshSkipped = (branch, code, reason, options) => {
     return {
         phaseKind: "sssql_optional_condition",
         kind: "optional_branch_skipped",
-        conditionSql: formatSqlComponent(branch.expression),
+        conditionSql: (0, SqlComponentFormatter_1.formatSqlComponent)(branch.expression, options),
         parameterName: branch.parameterName,
         code,
         reason
@@ -101,78 +108,94 @@ const buildSssqlRefreshFilters = (branches, parameters) => {
     }
     return filters;
 };
-const refreshRemainingSssqlBranches = (sql, parameters) => {
-    const parsed = parseConditionOptimizationInput(sql);
+const refreshRemainingSssqlBranches = (query, fallbackSql, parameters, options) => {
     const applied = [];
     const skipped = [];
-    if (!parsed.query) {
-        return {
-            sql: parsed.sql,
-            applied,
-            skipped,
-            warnings: parsed.warnings,
-            errors: parsed.errors,
-            formatterGeneratedSource: parsed.formatterGeneratedSource
-        };
-    }
-    const beforeBranches = (0, PruneOptionalConditionBranches_1.collectSupportedOptionalConditionBranches)(parsed.query);
+    const beforeBranches = (0, PruneOptionalConditionBranches_1.collectSupportedOptionalConditionBranches)(query);
     if (beforeBranches.length === 0) {
         return {
-            sql: parsed.sql,
+            query,
+            sql: fallbackSql,
             applied,
             skipped,
-            warnings: parsed.warnings,
-            errors: parsed.errors,
-            formatterGeneratedSource: parsed.formatterGeneratedSource
+            warnings: [],
+            errors: [],
+            formatterGeneratedSource: false
         };
     }
     const beforeBranchSql = new WeakMap();
     const beforeBranchQuery = new WeakMap();
     for (const branch of beforeBranches) {
-        beforeBranchSql.set(branch.expression, formatSqlComponent(branch.expression));
+        beforeBranchSql.set(branch.expression, (0, SqlComponentFormatter_1.formatSqlComponent)(branch.expression, options));
         beforeBranchQuery.set(branch.expression, branch.query);
     }
     try {
-        new SSSQLFilterBuilder_1.SSSQLFilterBuilder().refresh(parsed.query, buildSssqlRefreshFilters(beforeBranches, parameters));
+        new SSSQLFilterBuilder_1.SSSQLFilterBuilder().refresh(query, buildSssqlRefreshFilters(beforeBranches, parameters));
     }
     catch (error) {
         const detail = error instanceof Error ? error.message : String(error);
         return {
-            sql,
+            query,
+            sql: fallbackSql,
             applied,
-            skipped: beforeBranches.map(branch => buildSssqlRefreshSkipped(branch, "SSSQL_OPTIONAL_REFRESH_UNSUPPORTED", `SSSQL optional branch refresh was skipped because safe refresh could not be proven: ${detail}`)),
-            warnings: parsed.warnings,
-            errors: parsed.errors,
-            formatterGeneratedSource: parsed.formatterGeneratedSource
+            skipped: beforeBranches.map(branch => buildSssqlRefreshSkipped(branch, "SSSQL_OPTIONAL_REFRESH_UNSUPPORTED", `SSSQL optional branch refresh was skipped because safe refresh could not be proven: ${detail}`, options)),
+            warnings: [],
+            errors: [],
+            formatterGeneratedSource: false
         };
     }
-    const afterBranches = (0, PruneOptionalConditionBranches_1.collectSupportedOptionalConditionBranches)(parsed.query);
+    const afterBranches = (0, PruneOptionalConditionBranches_1.collectSupportedOptionalConditionBranches)(query);
     for (const branch of afterBranches) {
         const previousSql = beforeBranchSql.get(branch.expression);
         const previousQuery = beforeBranchQuery.get(branch.expression);
         if (!previousSql || !previousQuery) {
-            skipped.push(buildSssqlRefreshSkipped(branch, "SSSQL_OPTIONAL_REFRESH_UNSUPPORTED", "SSSQL optional branch refresh left an untracked branch unchanged."));
+            skipped.push(buildSssqlRefreshSkipped(branch, "SSSQL_OPTIONAL_REFRESH_UNSUPPORTED", "SSSQL optional branch refresh left an untracked branch unchanged.", options));
             continue;
         }
-        const refreshedSql = formatSqlComponent(branch.expression);
+        const refreshedSql = (0, SqlComponentFormatter_1.formatSqlComponent)(branch.expression, options);
         if (previousQuery !== branch.query || previousSql !== refreshedSql) {
-            applied.push(buildSssqlRefreshApplied(branch, previousSql));
+            applied.push(buildSssqlRefreshApplied(branch, previousSql, options));
             continue;
         }
-        skipped.push(buildSssqlRefreshSkipped(branch, "SSSQL_OPTIONAL_REFRESH_NOOP", "SSSQL optional branch refresh found no safe placement change to apply."));
+        skipped.push(buildSssqlRefreshSkipped(branch, "SSSQL_OPTIONAL_REFRESH_NOOP", "SSSQL optional branch refresh found no safe placement change to apply.", options));
     }
     return {
-        sql: applied.length > 0 ? formatSqlComponent(parsed.query) : sql,
+        query,
+        sql: applied.length > 0 || (0, SqlComponentFormatter_1.hasSqlComponentFormatOverride)(options)
+            ? (0, SqlComponentFormatter_1.formatSqlComponent)(query, options)
+            : fallbackSql,
         applied,
         skipped,
-        warnings: parsed.warnings,
-        errors: parsed.errors,
-        formatterGeneratedSource: parsed.formatterGeneratedSource
+        warnings: [],
+        errors: [],
+        formatterGeneratedSource: false
+    };
+};
+const refreshRemainingSssqlBranchesFromSql = (sql, parameters, options) => {
+    const parsed = parseConditionOptimizationInput(sql, options);
+    if (!parsed.query) {
+        return {
+            query: null,
+            sql: parsed.sql,
+            applied: [],
+            skipped: [],
+            warnings: parsed.warnings,
+            errors: parsed.errors,
+            formatterGeneratedSource: parsed.formatterGeneratedSource
+        };
+    }
+    const refreshed = refreshRemainingSssqlBranches(parsed.query, sql, parameters, options);
+    return {
+        ...refreshed,
+        warnings: [...parsed.warnings, ...refreshed.warnings],
+        errors: [...parsed.errors, ...refreshed.errors],
+        formatterGeneratedSource: parsed.formatterGeneratedSource || refreshed.formatterGeneratedSource
     };
 };
 const runSssqlOptionalConditionPhase = (input, options) => {
     var _a;
-    const parsed = parseConditionOptimizationInput(input);
+    const reuseOwnedModel = options.cloneInput === false && typeof input !== "string";
+    const parsed = parseConditionOptimizationInput(input, options);
     const warnings = [...parsed.warnings];
     let errors = [...parsed.errors];
     const applied = [];
@@ -180,6 +203,7 @@ const runSssqlOptionalConditionPhase = (input, options) => {
     const optionalConditionParameters = (_a = options.optionalConditionParameters) !== null && _a !== void 0 ? _a : {};
     if (!parsed.query) {
         return {
+            query: null,
             sql: parsed.sql,
             applied,
             skipped,
@@ -189,14 +213,16 @@ const runSssqlOptionalConditionPhase = (input, options) => {
         };
     }
     let currentSql = parsed.sql;
+    let currentQuery = parsed.query;
+    let formatterGeneratedSource = parsed.formatterGeneratedSource;
     const branches = (0, PruneOptionalConditionBranches_1.collectSupportedOptionalConditionBranches)(parsed.query);
     const pruneBranches = branches.filter(branch => hasOwnParameter(optionalConditionParameters, branch.parameterName)
         && isAbsentOptionalValue(optionalConditionParameters, branch.parameterName));
     if (pruneBranches.length > 0) {
         try {
             (0, PruneOptionalConditionBranches_1.pruneOptionalConditionBranches)(parsed.query, optionalConditionParameters);
-            currentSql = formatSqlComponent(parsed.query);
-            applied.push(...pruneBranches.map(buildSssqlApplied));
+            currentSql = (0, SqlComponentFormatter_1.formatSqlComponent)(parsed.query, options);
+            applied.push(...pruneBranches.map(branch => buildSssqlApplied(branch, options)));
         }
         catch (error) {
             errors = [...errors, {
@@ -208,28 +234,33 @@ const runSssqlOptionalConditionPhase = (input, options) => {
         }
     }
     if (errors.length === 0) {
-        const refreshPhase = refreshRemainingSssqlBranches(currentSql, optionalConditionParameters);
+        const refreshPhase = reuseOwnedModel
+            ? refreshRemainingSssqlBranches(parsed.query, currentSql, optionalConditionParameters, options)
+            : refreshRemainingSssqlBranchesFromSql(currentSql, optionalConditionParameters, options);
         applied.push(...refreshPhase.applied);
         skipped.push(...refreshPhase.skipped);
         warnings.push(...refreshPhase.warnings);
         errors.push(...refreshPhase.errors);
         currentSql = refreshPhase.sql;
+        currentQuery = refreshPhase.query;
+        formatterGeneratedSource = formatterGeneratedSource || refreshPhase.formatterGeneratedSource;
     }
     else {
         for (const branch of branches) {
             if (pruneBranches.includes(branch)) {
                 continue;
             }
-            skipped.push(buildSssqlSkipped(branch, optionalConditionParameters));
+            skipped.push(buildSssqlSkipped(branch, optionalConditionParameters, options));
         }
     }
     return {
+        query: errors.length === 0 ? currentQuery : null,
         sql: errors.length === 0 ? currentSql : parsed.sql,
         applied,
         skipped,
         warnings,
         errors,
-        formatterGeneratedSource: parsed.formatterGeneratedSource
+        formatterGeneratedSource
     };
 };
 const mapParameterWarnings = (warnings) => warnings.map(warning => ({
@@ -248,6 +279,22 @@ const mapParameterSkipped = (skipped) => skipped.map(item => ({
     phaseKind: "parameter_condition_placement",
     ...item
 }));
+const mapStaticWarnings = (warnings) => warnings.map(warning => ({
+    phaseKind: "static_predicate_placement",
+    ...warning
+}));
+const mapStaticErrors = (errors) => errors.map(error => ({
+    phaseKind: "static_predicate_placement",
+    ...error
+}));
+const mapStaticApplied = (applied) => applied.map(item => ({
+    phaseKind: "static_predicate_placement",
+    ...item
+}));
+const mapStaticSkipped = (skipped) => skipped.map(item => ({
+    phaseKind: "static_predicate_placement",
+    ...item
+}));
 const makePhaseSummary = (kind, counts) => ({
     kind,
     appliedCount: counts.appliedCount,
@@ -256,24 +303,50 @@ const makePhaseSummary = (kind, counts) => ({
     errorCount: counts.errorCount
 });
 const runConditionOptimization = (input, options, defaultDryRun) => {
-    var _a;
+    var _a, _b, _c;
     const dryRun = (_a = options.dryRun) !== null && _a !== void 0 ? _a : defaultDryRun;
-    // Run the semantic SSSQL phase before the generic placement phase so
-    // optional branches remain owned by SSSQL even if parameter placement grows
-    // broader OR-predicate support later.
+    const reuseOwnedModel = options.cloneInput === false && typeof input !== "string";
+    // Run semantic SSSQL handling before generic placement phases so optional
+    // branches remain owned by SSSQL even if later phases grow broader support.
     const sssqlPhase = runSssqlOptionalConditionPhase(input, { ...options, dryRun });
+    const parameterOptimizer = new ParameterConditionPlacementOptimizer_1.ParameterConditionPlacementOptimizer();
+    const parameterInput = reuseOwnedModel
+        ? (_b = sssqlPhase.query) !== null && _b !== void 0 ? _b : sssqlPhase.sql
+        : sssqlPhase.sql;
+    const parameterOptions = {
+        ...options,
+        dryRun,
+        cloneInput: reuseOwnedModel && sssqlPhase.query ? false : options.cloneInput
+    };
     const parameterPhase = dryRun
-        ? (0, ParameterConditionPlacementOptimizer_1.planParameterConditionOptimization)(sssqlPhase.sql, { dryRun })
-        : (0, ParameterConditionPlacementOptimizer_1.optimizeParameterConditionPlacement)(sssqlPhase.sql, { dryRun });
+        ? parameterOptimizer.plan(parameterInput, parameterOptions)
+        : parameterOptimizer.optimize(parameterInput, parameterOptions);
     const parameterWarnings = mapParameterWarnings(parameterPhase.warnings);
     const parameterErrors = mapParameterErrors(parameterPhase.errors);
     const parameterApplied = mapParameterApplied(parameterPhase.applied);
     const parameterSkipped = mapParameterSkipped(parameterPhase.skipped);
-    const warnings = [...sssqlPhase.warnings, ...parameterWarnings];
-    const errors = [...sssqlPhase.errors, ...parameterErrors];
+    const staticOptimizer = new StaticPredicatePlacementOptimizer_1.StaticPredicatePlacementOptimizer();
+    const staticInput = reuseOwnedModel
+        ? (_c = parameterPhase.query) !== null && _c !== void 0 ? _c : parameterPhase.sql
+        : parameterPhase.sql;
+    const staticOptions = {
+        ...options,
+        dryRun,
+        cloneInput: reuseOwnedModel && parameterPhase.query ? false : options.cloneInput
+    };
+    const staticPhase = dryRun
+        ? staticOptimizer.plan(staticInput, staticOptions)
+        : staticOptimizer.optimize(staticInput, staticOptions);
+    const staticWarnings = mapStaticWarnings(staticPhase.warnings);
+    const staticErrors = mapStaticErrors(staticPhase.errors);
+    const staticApplied = mapStaticApplied(staticPhase.applied);
+    const staticSkipped = mapStaticSkipped(staticPhase.skipped);
+    const warnings = [...sssqlPhase.warnings, ...parameterWarnings, ...staticWarnings];
+    const errors = [...sssqlPhase.errors, ...parameterErrors, ...staticErrors];
     return {
         ok: errors.length === 0,
-        sql: parameterPhase.sql,
+        sql: staticPhase.sql,
+        query: staticPhase.query,
         phases: [
             makePhaseSummary("sssql_optional_condition", {
                 appliedCount: sssqlPhase.applied.length,
@@ -286,17 +359,25 @@ const runConditionOptimization = (input, options, defaultDryRun) => {
                 skippedCount: parameterSkipped.length,
                 warningCount: parameterWarnings.length,
                 errorCount: parameterErrors.length
+            }),
+            makePhaseSummary("static_predicate_placement", {
+                appliedCount: staticApplied.length,
+                skippedCount: staticSkipped.length,
+                warningCount: staticWarnings.length,
+                errorCount: staticErrors.length
             })
         ],
-        applied: [...sssqlPhase.applied, ...parameterApplied],
-        skipped: [...sssqlPhase.skipped, ...parameterSkipped],
+        applied: [...sssqlPhase.applied, ...parameterApplied, ...staticApplied],
+        skipped: [...sssqlPhase.skipped, ...parameterSkipped, ...staticSkipped],
         warnings,
         errors,
         safety: {
             mode: "safe_only",
             unsafeRewriteApplied: false,
             dryRun,
-            formatterGeneratedSource: sssqlPhase.formatterGeneratedSource || parameterPhase.safety.formatterGeneratedSource
+            formatterGeneratedSource: sssqlPhase.formatterGeneratedSource
+                || parameterPhase.safety.formatterGeneratedSource
+                || staticPhase.safety.formatterGeneratedSource
         }
     };
 };