or-tools-wasm 0.5.0 → 0.7.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (52) hide show
  1. package/README.md +206 -54
  2. package/build/javascript/browser/cp_sat_module_loader.js +53 -0
  3. package/build/javascript/browser/cpsat_worker.js +135 -0
  4. package/build/javascript/browser/cpsat_worker_types.js +0 -0
  5. package/build/javascript/browser/index.js +5910 -0
  6. package/build/javascript/lib/assets/cp_sat_runtime-BcQ-oG9G.js +2568 -0
  7. package/build/javascript/lib/assets/cp_sat_runtime-BcQ-oG9G.js.map +1 -0
  8. package/build/javascript/lib/assets/{cp_sat_runtime-BUuF8d7w.wasm → cp_sat_runtime.wasm} +0 -0
  9. package/build/javascript/lib/assets/cp_sat_runtime.wasm.map +1 -0
  10. package/build/javascript/lib/assets/cp_sat_runtime_asyncify-CebveWgj.js +2642 -0
  11. package/build/javascript/lib/assets/cp_sat_runtime_asyncify-CebveWgj.js.map +1 -0
  12. package/build/javascript/lib/assets/{cp_sat_runtime_asyncify-CjMVqM1A.wasm → cp_sat_runtime_asyncify.wasm} +0 -0
  13. package/build/javascript/lib/assets/cp_sat_runtime_asyncify.wasm.map +1 -0
  14. package/build/javascript/lib/assets/cpsat_worker-CxyMtsph.js +145 -0
  15. package/build/javascript/lib/assets/cpsat_worker-CxyMtsph.js.map +1 -0
  16. package/build/javascript/lib/chunks/cp_sat_runtime-D-Bi0Puh.js +2568 -0
  17. package/build/javascript/lib/chunks/cp_sat_runtime-D-Bi0Puh.js.map +1 -0
  18. package/build/javascript/lib/chunks/cp_sat_runtime_asyncify-pyd1qgFK.js +2642 -0
  19. package/build/javascript/lib/chunks/cp_sat_runtime_asyncify-pyd1qgFK.js.map +1 -0
  20. package/build/javascript/lib/cp_sat_api.d.ts +277 -98
  21. package/build/javascript/lib/cp_sat_api.js +3364 -219
  22. package/build/javascript/lib/cp_sat_api.js.map +1 -1
  23. package/build/javascript/wasm/cp_sat_runtime.d.ts +51 -0
  24. package/build/javascript/wasm/cp_sat_runtime.js +10 -0
  25. package/build/javascript/wasm/cp_sat_runtime.wasm +0 -0
  26. package/build/javascript/wasm/cp_sat_runtime.wasm.map +1 -0
  27. package/build/javascript/wasm/cp_sat_runtime_asyncify.js +10 -0
  28. package/build/javascript/wasm/cp_sat_runtime_asyncify.wasm +0 -0
  29. package/build/javascript/wasm/cp_sat_runtime_asyncify.wasm.map +1 -0
  30. package/javascript/lib/cp_sat_api.ts +475 -0
  31. package/javascript/lib/cp_sat_module_loader.bundled.ts +58 -0
  32. package/javascript/lib/cp_sat_module_loader.ts +57 -0
  33. package/javascript/lib/cpsat_worker.ts +160 -0
  34. package/javascript/lib/cpsat_worker_types.ts +32 -0
  35. package/javascript/lib/generated/sat_parameters.ts +2760 -0
  36. package/javascript/lib/index.ts +8 -0
  37. package/javascript/lib/internal_wasm_asyncify.d.ts +15 -0
  38. package/javascript/lib/vite-shims.d.ts +25 -0
  39. package/javascript/lib/webassembly_promising.d.ts +7 -0
  40. package/package.json +46 -7
  41. package/build/javascript/lib/assets/cp_sat_runtime-N6mpxHFm.js +0 -2565
  42. package/build/javascript/lib/assets/cp_sat_runtime-N6mpxHFm.js.map +0 -1
  43. package/build/javascript/lib/assets/cp_sat_runtime_asyncify-DAFhCUmM.js +0 -2639
  44. package/build/javascript/lib/assets/cp_sat_runtime_asyncify-DAFhCUmM.js.map +0 -1
  45. package/build/javascript/lib/assets/cpsat_worker-Bc6EW-gj.js +0 -139
  46. package/build/javascript/lib/assets/cpsat_worker-Bc6EW-gj.js.map +0 -1
  47. package/build/javascript/lib/chunks/cp_sat_runtime-B9zhYjnh.js +0 -2565
  48. package/build/javascript/lib/chunks/cp_sat_runtime-B9zhYjnh.js.map +0 -1
  49. package/build/javascript/lib/chunks/cp_sat_runtime_asyncify-BaxdGqjW.js +0 -2639
  50. package/build/javascript/lib/chunks/cp_sat_runtime_asyncify-BaxdGqjW.js.map +0 -1
  51. package/build/javascript/lib/chunks/index-Cq3lJx2c.js +0 -3815
  52. package/build/javascript/lib/chunks/index-Cq3lJx2c.js.map +0 -1
@@ -1,10 +1,3 @@
1
- import { MainModule } from '../../build/javascript/wasm/cp_sat_runtime.js';
2
-
3
- declare type CancelSolve = {
4
- type: 'cancel_solve';
5
- id: number;
6
- };
7
-
8
1
  declare const CpSat: CpSatApi;
9
2
  export { CpSat }
10
3
  export default CpSat;
@@ -18,7 +11,7 @@ export declare type CpSatApi = {
18
11
  }>;
19
12
  getSchemas(): Promise<SchemaPair>;
20
13
  createModel(model: Record<string, unknown>): Promise<Uint8Array>;
21
- loadModule(): Promise<MainModule>;
14
+ loadModule(): Promise<unknown>;
22
15
  setWorkerBridgeEnabled(enabled: boolean): void;
23
16
  isWorkerBridgeEnabled(): boolean;
24
17
  cancelSolve(): Promise<void>;
@@ -34,7 +27,7 @@ export declare type CpSatSolveResult = {
34
27
  /**
35
28
  * Contains the definitions for all the sat algorithm parameters and their
36
29
  * default values.
37
- * NEXT TAG: 325
30
+ * NEXT TAG: 356
38
31
  */
39
32
  declare type SatParameters = {
40
33
  /**
@@ -132,7 +125,7 @@ declare type SatParameters = {
132
125
  */
133
126
  minimizationAlgorithm?: SatParameters_ConflictMinimizationAlgorithm | SatParameters_ConflictMinimizationAlgorithm_Name;
134
127
  /**
135
- * @default BINARY_MINIMIZATION_FIRST
128
+ * @default BINARY_MINIMIZATION_FROM_UIP_AND_DECISIONS
136
129
  */
137
130
  binaryMinimizationAlgorithm?: SatParameters_BinaryMinizationAlgorithm | SatParameters_BinaryMinizationAlgorithm_Name;
138
131
  /**
@@ -144,6 +137,58 @@ declare type SatParameters = {
144
137
  * @default true
145
138
  */
146
139
  subsumptionDuringConflictAnalysis?: boolean;
140
+ /**
141
+ * It is possible that "intermediate" clauses during conflict resolution
142
+ * subsumes some of the clauses that propagated. This is quite cheap to detect
143
+ * and result in more subsumption/strengthening of clauses.
144
+ *
145
+ * @default true
146
+ */
147
+ extraSubsumptionDuringConflictAnalysis?: boolean;
148
+ /**
149
+ * Try even more subsumption options during conflict analysis.
150
+ *
151
+ * @default true
152
+ */
153
+ decisionSubsumptionDuringConflictAnalysis?: boolean;
154
+ /**
155
+ * If >=0, each time we have a conflict, we try to subsume the last n learned
156
+ * clause with it.
157
+ *
158
+ * @default 4
159
+ */
160
+ eagerlySubsumeLastNConflicts?: number;
161
+ /**
162
+ * If we remove clause that we now are "implied" by others. Note that this
163
+ * might not always be good as we might loose some propagation power.
164
+ *
165
+ * @default true
166
+ */
167
+ subsumeDuringVivification?: boolean;
168
+ /**
169
+ * If true, try to backtrack as little as possible on conflict and re-imply
170
+ * the clauses later.
171
+ * This means we discard less propagation than traditional backjumping, but
172
+ * requites additional bookkeeping to handle reimplication.
173
+ * See: https://doi.org/10.1007/978-3-319-94144-8_7
174
+ *
175
+ * @default false
176
+ */
177
+ useChronologicalBacktracking?: boolean;
178
+ /**
179
+ * If chronological backtracking is enabled, this is the maximum number of
180
+ * levels we will backjump over, otherwise we will backtrack.
181
+ *
182
+ * @default 50
183
+ */
184
+ maxBackjumpLevels?: number;
185
+ /**
186
+ * If chronological backtracking is enabled, this is the minimum number of
187
+ * conflicts before we will consider backjumping.
188
+ *
189
+ * @default 1000
190
+ */
191
+ chronologicalBacktrackMinConflicts?: number;
147
192
  /**
148
193
  * ==========================================================================
149
194
  * Clause database management
@@ -153,6 +198,12 @@ declare type SatParameters = {
153
198
  * @default 10000
154
199
  */
155
200
  clauseCleanupPeriod?: number;
201
+ /**
202
+ * Increase clause_cleanup_period by this amount after each cleanup.
203
+ *
204
+ * @default 0
205
+ */
206
+ clauseCleanupPeriodIncrement?: number;
156
207
  /**
157
208
  * During a cleanup, we will always keep that number of "deletable" clauses.
158
209
  * Note that this doesn't include the "protected" clauses.
@@ -168,17 +219,34 @@ declare type SatParameters = {
168
219
  * @default 0
169
220
  */
170
221
  clauseCleanupRatio?: number;
171
- /**
172
- * @default PROTECTION_NONE
173
- */
174
- clauseCleanupProtection?: SatParameters_ClauseProtection | SatParameters_ClauseProtection_Name;
175
222
  /**
176
223
  * All the clauses with a LBD (literal blocks distance) lower or equal to this
177
224
  * parameters will always be kept.
225
+ * Note that the LBD of a clause that just propagated is 1 + number of
226
+ * different decision levels of its literals. So that the "classic" LBD of a
227
+ * learned conflict is the same as its LBD when we backjump and then propagate
228
+ * it.
178
229
  *
179
230
  * @default 5
180
231
  */
181
232
  clauseCleanupLbdBound?: number;
233
+ /**
234
+ * All the clause with a LBD lower or equal to this will be kept except if
235
+ * its activity hasn't been bumped in the last 32 cleanup phase. Note that
236
+ * this has no effect if it is <= clause_cleanup_lbd_bound.
237
+ *
238
+ * @default 0
239
+ */
240
+ clauseCleanupLbdTier1?: number;
241
+ /**
242
+ * All the clause with a LBD lower or equal to this will be kept except if its
243
+ * activity hasn't been bumped since the previous cleanup phase. Note that
244
+ * this has no effect if it is <= clause_cleanup_lbd_bound or <=
245
+ * clause_cleanup_lbd_tier1.
246
+ *
247
+ * @default 0
248
+ */
249
+ clauseCleanupLbdTier2?: number;
182
250
  /**
183
251
  * @default CLAUSE_ACTIVITY
184
252
  */
@@ -447,6 +515,11 @@ declare type SatParameters = {
447
515
  */
448
516
  logToResponse?: boolean;
449
517
  /**
518
+ * Experimental.
519
+ * This is an old experiment, it might cause crashes in multi-thread and you
520
+ * should double check the solver result. It can still be used if you only
521
+ * care about feasible solutions (these are checked) and it gives good result
522
+ * on your problem. We might revive it at some point.
450
523
  * Whether to use pseudo-Boolean resolution to analyze a conflict. Note that
451
524
  * this option only make sense if your problem is modelized using
452
525
  * pseudo-Boolean constraints. If you only have clauses, this shouldn't change
@@ -568,6 +641,16 @@ declare type SatParameters = {
568
641
  * @default true
569
642
  */
570
643
  cpModelUseSatPresolve?: boolean;
644
+ /**
645
+ * If we try to load at most ones and exactly ones constraints when running
646
+ * the pure SAT presolve. Or if we just ignore them.
647
+ * If one detects at_most_one via merge_at_most_one_work_limit or exactly one
648
+ * with find_clauses_that_are_exactly_one, it might be good to also set this
649
+ * to true.
650
+ *
651
+ * @default false
652
+ */
653
+ loadAtMostOnesInSatPresolve?: boolean;
571
654
  /**
572
655
  * If cp_model_presolve is true and there is a large proportion of fixed
573
656
  * variable after the first model copy, remap all the model to a dense set of
@@ -616,6 +699,12 @@ declare type SatParameters = {
616
699
  * @default true
617
700
  */
618
701
  expandReservoirConstraints?: boolean;
702
+ /**
703
+ * Max domain size for expanding linear2 constraints (ax + by ==/!= c).
704
+ *
705
+ * @default 8
706
+ */
707
+ maxDomainSizeForLinear2Expansion?: number;
619
708
  /**
620
709
  * Mainly useful for testing.
621
710
  * If this and expand_reservoir_constraints is true, we use a different
@@ -736,6 +825,16 @@ declare type SatParameters = {
736
825
  * @default true
737
826
  */
738
827
  findBigLinearOverlap?: boolean;
828
+ /**
829
+ * By propagating (or just using binary clauses), one can detect that all
830
+ * literal of a clause are actually in at most one relationship. Thus this
831
+ * constraint can be promoted to an exactly one constraints. This should help
832
+ * as it convey more structure. Note that this is expensive, so we have a
833
+ * deterministic limit in place.
834
+ *
835
+ * @default true
836
+ */
837
+ findClausesThatAreExactlyOne?: boolean;
739
838
  /**
740
839
  * ==========================================================================
741
840
  * Inprocessing
@@ -781,6 +880,22 @@ declare type SatParameters = {
781
880
  * @default false
782
881
  */
783
882
  inprocessingMinimizationUseAllOrderings?: boolean;
883
+ /**
884
+ * Whether we use the algorithm described in "Clausal Congruence closure",
885
+ * Armin Biere, Katalin Fazekas, Mathias Fleury, Nils Froleyks, 2024.
886
+ * Note that we only have a basic version currently.
887
+ *
888
+ * @default true
889
+ */
890
+ inprocessingUseCongruenceClosure?: boolean;
891
+ /**
892
+ * Whether we use the SAT sweeping algorithm described in "Clausal Equivalence
893
+ * Sweeping", Armin Biere, Katalin Fazekas, Mathias Fleury, Nils Froleyks,
894
+ * 2025.
895
+ *
896
+ * @default false
897
+ */
898
+ inprocessingUseSatSweeping?: boolean;
784
899
  /**
785
900
  * ==========================================================================
786
901
  * Multithread
@@ -890,6 +1005,15 @@ declare type SatParameters = {
890
1005
  * @default true
891
1006
  */
892
1007
  shareLevelZeroBounds?: boolean;
1008
+ /**
1009
+ * Allows sharing of the bounds on linear2 discovered at level 0. This is
1010
+ * mainly interesting on scheduling type of problems when we branch on
1011
+ * precedences.
1012
+ * Warning: This currently non-deterministic.
1013
+ *
1014
+ * @default false
1015
+ */
1016
+ shareLinear2Bounds?: boolean;
893
1017
  /**
894
1018
  * Allows sharing of new learned binary clause between workers.
895
1019
  *
@@ -900,7 +1024,7 @@ declare type SatParameters = {
900
1024
  * Allows sharing of short glue clauses between workers.
901
1025
  * Implicitly disabled if share_binary_clauses is false.
902
1026
  *
903
- * @default false
1027
+ * @default true
904
1028
  */
905
1029
  shareGlueClauses?: boolean;
906
1030
  /**
@@ -916,6 +1040,75 @@ declare type SatParameters = {
916
1040
  * @default 1
917
1041
  */
918
1042
  shareGlueClausesDtime?: number;
1043
+ /**
1044
+ * ==========================================================================
1045
+ * Proofs
1046
+ * ==========================================================================
1047
+ * If true, inferred clauses are checked with an LRAT checker as they are
1048
+ * learned, in presolve (reduced to trivial simplifications if
1049
+ * cp_model_presolve is false), and in each worker. As of December 2025, this
1050
+ * only works with pure SAT problems, with
1051
+ * - cp_model_presolve = false,
1052
+ * - linearization_level <= 1,
1053
+ * - symmetry_level <= 1.
1054
+ *
1055
+ * @default false
1056
+ */
1057
+ checkLratProof?: boolean;
1058
+ /**
1059
+ * If true, and if output_lrat_proof is true and the problem is UNSAT, check
1060
+ * that the merged proof file is valid, i.e., that clause sharing between
1061
+ * workers is correct. This checks each inferred clause, so you might want to
1062
+ * disable check_lrat_proof to avoid redundant work. As of November 2025, this
1063
+ * only works for pure SAT problems, with num_workers = 1.
1064
+ *
1065
+ * @default false
1066
+ */
1067
+ checkMergedLratProof?: boolean;
1068
+ /**
1069
+ * If true, an LRAT proof that all the clauses inferred by the solver are
1070
+ * valid is output to several files (one for presolve -- reduced to trivial
1071
+ * simplifications if cp_model_presolve is false, one per worker, and one for
1072
+ * the merged proof). As of December 2025, this only works for pure SAT
1073
+ * problems, with
1074
+ * - cp_model_presolve = false,
1075
+ * - linearization_level <= 1,
1076
+ * - symmetry_level <= 1.
1077
+ *
1078
+ * @default false
1079
+ */
1080
+ outputLratProof?: boolean;
1081
+ /**
1082
+ * If true, and if the problem is UNSAT, a DRAT proof of this UNSAT property
1083
+ * is checked after the solver has finished. As of November 2025, this only
1084
+ * works for pure SAT problems, with
1085
+ * - num_workers = 1,
1086
+ * - cp_model_presolve = false,
1087
+ * - linearization_level <= 1,
1088
+ * - symmetry_level <= 1.
1089
+ *
1090
+ * @default false
1091
+ */
1092
+ checkDratProof?: boolean;
1093
+ /**
1094
+ * If true, a DRAT proof that all the clauses inferred by the solver are valid
1095
+ * is output to a file. As of December 2025, this only works for pure SAT
1096
+ * problems, with
1097
+ * - num_workers = 1,
1098
+ * - cp_model_presolve = false,
1099
+ * - linearization_level <= 1,
1100
+ * - symmetry_level <= 1.
1101
+ *
1102
+ * @default false
1103
+ */
1104
+ outputDratProof?: boolean;
1105
+ /**
1106
+ * The maximum time allowed to check the DRAT proof (this can take more time
1107
+ * than the solve itself). Only used if check_drat_proof is true.
1108
+ *
1109
+ * @default inf
1110
+ */
1111
+ maxDratTimeInSeconds?: number;
919
1112
  /**
920
1113
  * ==========================================================================
921
1114
  * Debugging parameters
@@ -946,6 +1139,12 @@ declare type SatParameters = {
946
1139
  * @default false
947
1140
  */
948
1141
  debugCrashIfPresolveBreaksHint?: boolean;
1142
+ /**
1143
+ * Crash if the LRAT UNSAT proof is invalid.
1144
+ *
1145
+ * @default false
1146
+ */
1147
+ debugCrashIfLratCheckFails?: boolean;
949
1148
  /**
950
1149
  * ==========================================================================
951
1150
  * Max-sat parameters
@@ -1026,6 +1225,14 @@ declare type SatParameters = {
1026
1225
  * @default true
1027
1226
  */
1028
1227
  usePrecedencesInDisjunctiveConstraint?: boolean;
1228
+ /**
1229
+ * At root level, we might compute the transitive closure of "precedences"
1230
+ * relations so that we can exploit that in scheduling problems. Setting this
1231
+ * to zero disable the feature.
1232
+ *
1233
+ * @default 1000000
1234
+ */
1235
+ transitivePrecedencesWorkLimit?: number;
1029
1236
  /**
1030
1237
  * Create one literal for each disjunction of two pairs of tasks. This slows
1031
1238
  * down the solve time, but improves the lower bound of the objective in the
@@ -1523,7 +1730,7 @@ declare type SatParameters = {
1523
1730
  * Specifying a negative number uses a heuristic to select an appropriate
1524
1731
  * number of shared tree workeres based on the total number of workers.
1525
1732
  *
1526
- * @default 0
1733
+ * @default -1
1527
1734
  */
1528
1735
  sharedTreeNumWorkers?: number;
1529
1736
  /**
@@ -1585,12 +1792,22 @@ declare type SatParameters = {
1585
1792
  */
1586
1793
  sharedTreeBalanceTolerance?: number;
1587
1794
  /**
1588
- * Whether we enumerate all solutions of a problem without objective. Note
1589
- * that setting this to true automatically disable some presolve reduction
1590
- * that can remove feasible solution. That is it has the same effect as
1591
- * setting keep_all_feasible_solutions_in_presolve.
1592
- * TODO(user): Do not do that and let the user choose what behavior is best by
1593
- * setting keep_all_feasible_solutions_in_presolve ?
1795
+ * How much dtime a worker will wait between proposing splits.
1796
+ * This limits the contention in splitting the shared tree, and also reduces
1797
+ * the number of too-easy subtrees that are generates.
1798
+ *
1799
+ * @default 0
1800
+ */
1801
+ sharedTreeSplitMinDtime?: number;
1802
+ /**
1803
+ * Whether we enumerate all solutions of a problem without objective.
1804
+ * WARNING:
1805
+ * - This can be used with num_workers > 1 but then each solutions can be
1806
+ * found more than once, so it is up to the client to deduplicate them.
1807
+ * - If keep_all_feasible_solutions_in_presolve is unset, we will set it to
1808
+ * true as otherwise, many feasible solution can just be removed by the
1809
+ * presolve. It is still possible to manually set this to false if one only
1810
+ * wants to enumerate all solutions of the presolved model.
1594
1811
  *
1595
1812
  * @default false
1596
1813
  */
@@ -1690,12 +1907,29 @@ declare type SatParameters = {
1690
1907
  useLnsOnly?: boolean;
1691
1908
  /**
1692
1909
  * Size of the top-n different solutions kept by the solver.
1693
- * This parameter must be > 0.
1694
- * Currently this only impact the "base" solution chosen for a LNS fragment.
1910
+ * This parameter must be > 0. Currently, having this larger than one mainly
1911
+ * impact the "base" solution chosen for a LNS/LS fragment.
1695
1912
  *
1696
1913
  * @default 3
1697
1914
  */
1698
1915
  solutionPoolSize?: number;
1916
+ /**
1917
+ * If solution_pool_size is <= this, we will use DP to keep a "diverse" set
1918
+ * of solutions (the one further apart via hamming distance) in the pool.
1919
+ * Setting this to large value might be slow, especially if your solution are
1920
+ * large.
1921
+ *
1922
+ * @default 10
1923
+ */
1924
+ solutionPoolDiversityLimit?: number;
1925
+ /**
1926
+ * In order to not get stuck in local optima, when this is non-zero, we try to
1927
+ * also work on "older" solutions with a worse objective value so we get a
1928
+ * chance to follow a different LS/LNS trajectory.
1929
+ *
1930
+ * @default 1
1931
+ */
1932
+ alternativePoolSize?: number;
1699
1933
  /**
1700
1934
  * Turns on relaxation induced neighborhood generator.
1701
1935
  *
@@ -2131,6 +2365,20 @@ declare type SatParameters = {
2131
2365
  * @default false
2132
2366
  */
2133
2367
  detectLinearizedProduct?: boolean;
2368
+ /**
2369
+ * This should be better on integer problems.
2370
+ * But it is still work in progress.
2371
+ *
2372
+ * @default false
2373
+ */
2374
+ useNewIntegerConflictResolution?: boolean;
2375
+ /**
2376
+ * If true, and during integer conflict resolution (icr) the 1-UIP is an
2377
+ * integer literal for which we do not have an associated Boolean. Create one.
2378
+ *
2379
+ * @default true
2380
+ */
2381
+ create1uipBooleanDuringIcr?: boolean;
2134
2382
  /**
2135
2383
  * ==========================================================================
2136
2384
  * MIP -> CP-SAT (i.e. IP with integer coeff) conversion parameters that are
@@ -2280,13 +2528,11 @@ declare type SatParameters = {
2280
2528
  */
2281
2529
  declare enum SatParameters_BinaryMinizationAlgorithm {
2282
2530
  NO_BINARY_MINIMIZATION = 0,
2283
- BINARY_MINIMIZATION_FIRST = 1,
2284
- BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION = 4,
2285
- BINARY_MINIMIZATION_WITH_REACHABILITY = 2,
2286
- EXPERIMENTAL_BINARY_MINIMIZATION = 3
2531
+ BINARY_MINIMIZATION_FROM_UIP = 1,
2532
+ BINARY_MINIMIZATION_FROM_UIP_AND_DECISIONS = 5
2287
2533
  }
2288
2534
 
2289
- declare type SatParameters_BinaryMinizationAlgorithm_Name = 'NO_BINARY_MINIMIZATION' | 'BINARY_MINIMIZATION_FIRST' | 'BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION' | 'BINARY_MINIMIZATION_WITH_REACHABILITY' | 'EXPERIMENTAL_BINARY_MINIMIZATION';
2535
+ declare type SatParameters_BinaryMinizationAlgorithm_Name = 'NO_BINARY_MINIMIZATION' | 'BINARY_MINIMIZATION_FROM_UIP' | 'BINARY_MINIMIZATION_FROM_UIP_AND_DECISIONS';
2290
2536
 
2291
2537
  /**
2292
2538
  * The clauses that will be kept during a cleanup are the ones that come
@@ -2305,25 +2551,6 @@ declare enum SatParameters_ClauseOrdering {
2305
2551
 
2306
2552
  declare type SatParameters_ClauseOrdering_Name = 'CLAUSE_ACTIVITY' | 'CLAUSE_LBD';
2307
2553
 
2308
- /**
2309
- * Each time a clause activity is bumped, the clause has a chance to be
2310
- * protected during the next cleanup phase. Note that clauses used as a reason
2311
- * are always protected.
2312
- */
2313
- declare enum SatParameters_ClauseProtection {
2314
- PROTECTION_NONE = 0,
2315
- /**
2316
- * No protection.
2317
- */
2318
- PROTECTION_ALWAYS = 1,
2319
- /**
2320
- * Protect all clauses whose activity is bumped.
2321
- */
2322
- PROTECTION_LBD = 2
2323
- }
2324
-
2325
- declare type SatParameters_ClauseProtection_Name = 'PROTECTION_NONE' | 'PROTECTION_ALWAYS' | 'PROTECTION_LBD';
2326
-
2327
2554
  /**
2328
2555
  * ==========================================================================
2329
2556
  * Conflict analysis
@@ -2333,11 +2560,10 @@ declare type SatParameters_ClauseProtection_Name = 'PROTECTION_NONE' | 'PROTECTI
2333
2560
  declare enum SatParameters_ConflictMinimizationAlgorithm {
2334
2561
  NONE = 0,
2335
2562
  SIMPLE = 1,
2336
- RECURSIVE = 2,
2337
- EXPERIMENTAL = 3
2563
+ RECURSIVE = 2
2338
2564
  }
2339
2565
 
2340
- declare type SatParameters_ConflictMinimizationAlgorithm_Name = 'NONE' | 'SIMPLE' | 'RECURSIVE' | 'EXPERIMENTAL';
2566
+ declare type SatParameters_ConflictMinimizationAlgorithm_Name = 'NONE' | 'SIMPLE' | 'RECURSIVE';
2341
2567
 
2342
2568
  /**
2343
2569
  * Rounding method to use for feasibility pump.
@@ -2567,53 +2793,6 @@ declare type SchemaPair = {
2567
2793
  sat_parameters: string;
2568
2794
  };
2569
2795
 
2570
- declare type SchemaRequest = {
2571
- type: 'getSchemas';
2572
- id: number;
2573
- };
2574
-
2575
- declare type SolveRequest = {
2576
- type: 'solve';
2577
- id: number;
2578
- modelBytes: Uint8Array;
2579
- paramsBytes?: Uint8Array;
2580
- };
2581
-
2582
2796
  declare type SolverParams = Uint8Array | SatParameters | null;
2583
2797
 
2584
- declare type ValidateRequest = {
2585
- type: 'validate';
2586
- id: number;
2587
- modelBytes: Uint8Array;
2588
- };
2589
-
2590
- export declare type WorkerRequest = SolveRequest | ValidateRequest | SchemaRequest | CancelSolve;
2591
-
2592
- export declare type WorkerResponse = {
2593
- type: 'ready';
2594
- } | {
2595
- type: 'solveResult';
2596
- id: number;
2597
- bytes: Uint8Array;
2598
- } | {
2599
- type: 'validateResult';
2600
- id: number;
2601
- ok: boolean;
2602
- message: string;
2603
- } | {
2604
- type: 'schemaResult';
2605
- id: number;
2606
- schemas: {
2607
- cp_model: string;
2608
- sat_parameters: string;
2609
- };
2610
- } | {
2611
- type: 'solved_cancelled';
2612
- id: number;
2613
- } | {
2614
- type: 'error';
2615
- id: number;
2616
- error: string;
2617
- };
2618
-
2619
2798
  export { }