makepst 0.1.0__tar.gz → 0.2.0__tar.gz

{makepst-0.1.0 → makepst-0.2.0}/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.2.0 (2026-09-19)
+
+- `update`: the xlwings backend reads only headers, name and target columns, writes contiguous
+  cells in one call per run, suspends events and calculation while writing and recalculates
+  once before saving (1,068 parameters over eight sheets of a 27-sheet workbook: ~9 s, was
+  minutes); `--par` with `--pst` no longer rewrites the observation sheets
+- `tempchek`: check a template file or write model input files from parameter values, with
+  PEST's number writer (maximum precision in the space, `PRECIS` / `DPOINT`, one word per
+  parameter, right-justified; checked against `tempchek.exe`); for a template + `.par` file
+  or for a whole case
+- `inschek`: check an instruction file or read a model output file with it into an `.obf`
+  file, for one file or a whole case
+- `validate`: values that cannot be written into their template space are errors; a line
+  advance not at the start of an instruction line and `t` / fixed instructions moving left
+  are errors (INSCHEK's rules); three more pestchek warnings (empty observation group,
+  `ICOV`/`ICOR`/`IEIG` with more than 300 adjustable parameters, PEST_HP-only variables —
+  the last as a note); an all-zero-weight observation group is now a note, not a warning
+- `update`: cells inside array formulas or dynamic-array spill ranges are left alone (Excel
+  refuses them; xlwings no longer shows a dialog); names present on only one side are reported
+  with counts and examples
+- `validate`: pestchek's rules added (parameter data, groups, observations, prior information,
+  ~60 control-variable ranges and consistency rules, template and instruction syntax), derived
+  from PEST 17's `pestchek.F` / `cheksub.F`; file paths resolved from the directory PEST runs
+  in, not only the control file's folder
+
 ## 0.1.0 (2026-09-19)
 
 First packaged release; replaces the single-file `makePst.py` script.

{makepst-0.1.0 → makepst-0.2.0}/CITATION.cff

@@ -6,7 +6,7 @@ authors:
   - family-names: Ou
     given-names: Michael
     email: ougengxin@gmail.com
-version: 0.1.0
+version: 0.2.0
 date-released: 2026-09-19
 repository-code: "https://github.com/ougx/makePst"
 license: MIT

{makepst-0.1.0 → makepst-0.2.0}/MANIFEST.in

@@ -1,4 +1,5 @@
 include LICENSE README.md CHANGELOG.md CITATION.cff
 recursive-include tests *.py *.xlsx *.pst *.par *.res *.csv
-recursive-include examples *.csv *.py *.tpl *.ins *.in *.out *.par *.res
+recursive-include examples/minimal *.csv *.py *.tpl *.ins *.in *.out *.par *.res
+prune examples/mnnrd
 global-exclude __pycache__ *.py[cod] *.manifest.json

{makepst-0.1.0 → makepst-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: makepst
-Version: 0.1.0
+Version: 0.2.0
 Summary: Build PEST / PEST++ / PEST_HP control files from spreadsheet tables, read them back, and push results into the workbook
 Author-email: Michael Ou <ougengxin@gmail.com>
 License: MIT
@@ -120,6 +120,10 @@ makepst build model.pst regul --set_ctl_csv control.csv --add_pargp_csv pargp.cs
 # 2. check it against the template / instruction / output files, like pestchek
 makepst validate model.pst --outputs
 
+# 2b. what PEST will do with them: write the model input file, read the model output files
+makepst tempchek model.pst --dry_run
+makepst inschek model.pst
+
 # 3. control file -> workbook (CONTROL / PARGP / PAR / OBS / PRIOR / IO sheets + a BUILD sheet)
 makepst dump model.pst model.xlsx
 
@@ -154,8 +158,10 @@ makepst validate model.pst --outputs
 makepst validate book.xlsm --strict
 ```
 
-See [Validation](#validation). Template and instruction paths are resolved relative to the
-control file (or workbook); `--base_dir` overrides that. `--strict` also fails on warnings,
+See [Validation](#validation). Template and instruction paths are resolved the way PEST
+resolves them, from the directory PEST is run in: makePst tries the control file's folder,
+the current directory and the control file's parent, uses the one where the files are, and
+says which; `--base_dir` overrides that. `--strict` also fails on warnings,
 `--quiet` hides the informational lines.
 
 ### build — tables → .pst
@@ -225,10 +231,19 @@ makepst update book.xlsm --obs_csv run.3.obs.csv --pst run.pst  # IES simulated
 
 Every worksheet whose header row contains `PARNME` (or `OBSNME`) is matched row by row on the
 name, so tables spread over several sheets are all found; only the requested columns are
-written and only for names present in the source. Cells that hold formulas are left alone
-unless `--overwrite_formulas`. `--sheet` (glob, case-insensitive) restricts the worksheets;
+written and only for names present in both: names in the results with no row in the workbook,
+and workbook rows absent from the results, are left alone and reported as a warning with
+counts and examples. Cells that hold formulas are left alone unless `--overwrite_formulas`;
+cells inside an array formula or a dynamic-array spill range are never written (Excel would
+refuse), only counted. `--sheet` (glob, case-insensitive) restricts the worksheets;
 `--group` restricts the parameter / observation groups (a `.par` file carries no groups, so
-add `--pst` to supply them).
+add `--pst` to supply them). `--pst` on its own writes the control file's parameter and
+observation columns; next to `--par`, `--res` or `--obs_csv` it only supplies groups and
+measured values, and the observation sheets are not touched by a parameter update.
+
+The xlwings backend reads only each sheet's header, name column and target columns, writes
+contiguous runs of cells in one call each and recalculates once before saving: the
+demonstration workbook (27 sheets, 1,068 parameters over eight sheets) updates in about 9 s.
 
 PESTPP-IES ensembles (`case.N.par.csv`, `case.N.obs.csv`) are recognised by their
 `real_name` header. `--real` picks the realization: a name (`base`, `17`) or `best` — the
@@ -268,6 +283,41 @@ to that workbook; other relative names resolve against the workbook's folder. No
 route rebuilds from the workbook's *current* state, so any edits made since the original
 control file was written are picked up too.
 
+### tempchek — templates → model input files
+
+```
+makepst tempchek model.tpl                          # check the template, list its parameters
+makepst tempchek model.tpl model.in [model.par]     # write model.in (values from model.par by default)
+makepst tempchek model.pst [--par run.par] [--real best] [--dry_run]   # every template of the case
+```
+
+Like PEST's TEMPCHEK: a template is checked, then its model input file is written with
+parameter values from a `.par` file (or, given a control file / workbook, from `PARVAL1`
+with `SCALE` and `OFFSET` applied, or from `--par` — a `.par` file or an IES realization).
+Numbers are written the way PEST writes them (its `WRTSIG`): into the parameter space with
+as much precision as the space allows, fixed or exponential notation, right-justified, one
+word per parameter sized for its narrowest space, `PRECIS` / `DPOINT` honoured
+(`double`, `nopoint`). Checked against `tempchek.exe` on a grid of values and widths from 3
+to 23 characters: the same fields are refused, and the written value is never further from
+the true value than PEST's. A value that cannot be written (`1e-10` in a five-character
+space, say) is an error and nothing is written; parameters in the `.par` file that the
+template does not cite are warnings. `--dry_run` checks without writing.
+
+### inschek — model output files → observation values
+
+```
+makepst inschek heads.ins                           # check the instruction file, list its observations
+makepst inschek heads.ins heads.out [--out heads.obf]
+makepst inschek model.pst [--out model.obf]          # every instruction file of the case, one .obf
+```
+
+Like PEST's INSCHEK: the instruction file is checked (the syntax rules in the validation
+table below, including that a line advance can only start an instruction line and that fixed
+/ tab instructions must move right), then read against the model output file with the
+interpreter that `validate --outputs` uses, and the values go to an observation value file
+(`name  value` per line, INSCHEK's `.obf`). With a control file, all instruction files are
+read and observations the control file lists but no file produced are reported.
+
 ### diff — what changed
 
 ```
@@ -358,6 +408,12 @@ makepst validate tr13.xlsm            # a workbook with a BUILD sheet is built f
 | malformed prior equation; non-numeric right-hand side; `log()` used on a non-log parameter or vice versa | error |
 | `DERCOM` beyond the number of model command lines | error |
 | name longer than PEST's limit (12 parameter / 20 observation / 12 group; PEST++ allows 200) | warning |
+| **pestchek's rules** (from PEST 17's `pestchek.F` / `cheksub.F`): `PARCHGLIM` vocabulary and `absolute(n)` needing `absparmax(n)=`; log parameters factor-limited with positive values; factor-limited bounds of one sign and non-zero; `SCALE ≠ 0`; tied to itself, tied or parent with initial value 0; group `none` reserved; all parameters fixed/tied; `INCTYP` / `FORCEN` / `DERMTHD` vocabularies and their compatibility; split-column ranges; duplicate groups; `dum` as an observation name; prior weights, labels (≤ 20, not an observation name), duplicated parameters, all-zero factors, group `predict`; regularisation needs a `regul*` group, prediction exactly one `predict` observation; ~60 control-variable range and consistency rules (`RLAMFAC`, `PHIRATSUF`, `FACPARMAX`, `NPHISTP`, `RELPARSTP < RELPARMAX`, `EIGTHRESH`, `PHIMLIM < PHIMACCEPT < 1.2·PHIMLIM`, `WFMIN ≤ WFINIT ≤ WFMAX`, `UPTESTMIN`/`UPTESTLIM`, SVD vs AUI vs LSQR exclusivity, …) | error |
+| pestchek's warnings: derivative increment larger than a third of the range; initial value 0 with a relative increment; group with only fixed/tied parameters; log parameters with a non-relative increment; observation group listed but empty (dropped on write); `MAXSING` above the adjustable-parameter count; more than 300 adjustable parameters with `ICOV`/`ICOR`/`IEIG` on; `NOPTMAX 0` | warning |
+| PEST_HP-only control variables present (`WIN_MRUN_HOURS`, `UPTESTMIN`, `RRFSAVE`, …; plain PEST needs `/hpstart`); observation group whose weights are all zero | note |
+| template: parameter space narrower than 3 characters or containing a tab | error |
+| template: a value that cannot be written into its space as PEST writes numbers (`PRECIS` / `DPOINT` honoured), e.g. `1e-10` in five characters | error |
+| instruction file syntax: `l` / `t` integers, marker delimiters, `!` balance, `[name]n1:n2` order, `dum` in a fixed field, continuation `&` placement, `l` only at the start of a line, `t` and fixed columns moving left to right, unknown instructions — checked statically, without model output | error |
 | section in the `.pst` that makePst drops on read | warning |
 | template or instruction file missing; bad `ptf` / `pif` line | error |
 | parameter cited in no template; template citing an unknown parameter | error |
@@ -383,7 +439,7 @@ from?" after the fact:
 
 ```json
 {
-  "makepst": "0.1.0",
+  "makepst": "0.2.0",
   "command": "build",
   "argv": ["build", "tr13.pst", "regul", "--set_ctl_xls", "tr13.xlsm,CONTROL", "..."],
   "created": "2026-09-19T13:51:39-04:00",
@@ -454,7 +510,7 @@ update_workbook('book.xlsm', par='run.par', res='run.res', out='book_results.xls
 python -m pytest tests -q
 ```
 
-95 tests, no external data needed: a synthetic workbook in the real project layout
+106 tests, no external data needed: a synthetic workbook in the real project layout
 (`tests/data/demo.xlsx`, generated by `tests/make_fixture.py`) with a golden control file,
 `.par`, `.res` and IES ensemble files. They cover golden-file builds from Excel and CSV, the
 `read → write → read` identity, `dump → build` byte equality, workbook updates (multi-sheet
@@ -476,11 +532,13 @@ makepst/
   writer.py         Pst -> .pst text (+ dump.tpl)
   reader.py         .pst text -> Pst
   excel.py          sheets -> Pst; Pst -> workbook; results -> existing workbook
-  cli.py            init / validate / build / dump / update / parrep / diff
+  cli.py            init / validate / build / dump / update / parrep / diff / tempchek / inschek
   diff.py           semantic comparison of two Pst objects
   phi.py            objective function by group from residuals; IES realization phis
   pyemu_bridge.py   to_pyemu / from_pyemu
   checks.py         the validate report: table checks, template / instruction cross-checks, instruction interpreter
+  rules.py          pestchek's rules (parameters, groups, observations, prior information, control variables)
+  model_files.py    PEST's number writer, template filling, .obf files (tempchek / inschek)
   provenance.py     the <output>.manifest.json sidecar
   starter.py        the `init` workbook: control-variable descriptions, example rows, drop-downs
 examples/minimal/   the tutorial inputs

{makepst-0.1.0 → makepst-0.2.0}/README.md

@@ -89,6 +89,10 @@ makepst build model.pst regul --set_ctl_csv control.csv --add_pargp_csv pargp.cs
 # 2. check it against the template / instruction / output files, like pestchek
 makepst validate model.pst --outputs
 
+# 2b. what PEST will do with them: write the model input file, read the model output files
+makepst tempchek model.pst --dry_run
+makepst inschek model.pst
+
 # 3. control file -> workbook (CONTROL / PARGP / PAR / OBS / PRIOR / IO sheets + a BUILD sheet)
 makepst dump model.pst model.xlsx
 
@@ -123,8 +127,10 @@ makepst validate model.pst --outputs
 makepst validate book.xlsm --strict
 ```
 
-See [Validation](#validation). Template and instruction paths are resolved relative to the
-control file (or workbook); `--base_dir` overrides that. `--strict` also fails on warnings,
+See [Validation](#validation). Template and instruction paths are resolved the way PEST
+resolves them, from the directory PEST is run in: makePst tries the control file's folder,
+the current directory and the control file's parent, uses the one where the files are, and
+says which; `--base_dir` overrides that. `--strict` also fails on warnings,
 `--quiet` hides the informational lines.
 
 ### build — tables → .pst
@@ -194,10 +200,19 @@ makepst update book.xlsm --obs_csv run.3.obs.csv --pst run.pst  # IES simulated
 
 Every worksheet whose header row contains `PARNME` (or `OBSNME`) is matched row by row on the
 name, so tables spread over several sheets are all found; only the requested columns are
-written and only for names present in the source. Cells that hold formulas are left alone
-unless `--overwrite_formulas`. `--sheet` (glob, case-insensitive) restricts the worksheets;
+written and only for names present in both: names in the results with no row in the workbook,
+and workbook rows absent from the results, are left alone and reported as a warning with
+counts and examples. Cells that hold formulas are left alone unless `--overwrite_formulas`;
+cells inside an array formula or a dynamic-array spill range are never written (Excel would
+refuse), only counted. `--sheet` (glob, case-insensitive) restricts the worksheets;
 `--group` restricts the parameter / observation groups (a `.par` file carries no groups, so
-add `--pst` to supply them).
+add `--pst` to supply them). `--pst` on its own writes the control file's parameter and
+observation columns; next to `--par`, `--res` or `--obs_csv` it only supplies groups and
+measured values, and the observation sheets are not touched by a parameter update.
+
+The xlwings backend reads only each sheet's header, name column and target columns, writes
+contiguous runs of cells in one call each and recalculates once before saving: the
+demonstration workbook (27 sheets, 1,068 parameters over eight sheets) updates in about 9 s.
 
 PESTPP-IES ensembles (`case.N.par.csv`, `case.N.obs.csv`) are recognised by their
 `real_name` header. `--real` picks the realization: a name (`base`, `17`) or `best` — the
@@ -237,6 +252,41 @@ to that workbook; other relative names resolve against the workbook's folder. No
 route rebuilds from the workbook's *current* state, so any edits made since the original
 control file was written are picked up too.
 
+### tempchek — templates → model input files
+
+```
+makepst tempchek model.tpl                          # check the template, list its parameters
+makepst tempchek model.tpl model.in [model.par]     # write model.in (values from model.par by default)
+makepst tempchek model.pst [--par run.par] [--real best] [--dry_run]   # every template of the case
+```
+
+Like PEST's TEMPCHEK: a template is checked, then its model input file is written with
+parameter values from a `.par` file (or, given a control file / workbook, from `PARVAL1`
+with `SCALE` and `OFFSET` applied, or from `--par` — a `.par` file or an IES realization).
+Numbers are written the way PEST writes them (its `WRTSIG`): into the parameter space with
+as much precision as the space allows, fixed or exponential notation, right-justified, one
+word per parameter sized for its narrowest space, `PRECIS` / `DPOINT` honoured
+(`double`, `nopoint`). Checked against `tempchek.exe` on a grid of values and widths from 3
+to 23 characters: the same fields are refused, and the written value is never further from
+the true value than PEST's. A value that cannot be written (`1e-10` in a five-character
+space, say) is an error and nothing is written; parameters in the `.par` file that the
+template does not cite are warnings. `--dry_run` checks without writing.
+
+### inschek — model output files → observation values
+
+```
+makepst inschek heads.ins                           # check the instruction file, list its observations
+makepst inschek heads.ins heads.out [--out heads.obf]
+makepst inschek model.pst [--out model.obf]          # every instruction file of the case, one .obf
+```
+
+Like PEST's INSCHEK: the instruction file is checked (the syntax rules in the validation
+table below, including that a line advance can only start an instruction line and that fixed
+/ tab instructions must move right), then read against the model output file with the
+interpreter that `validate --outputs` uses, and the values go to an observation value file
+(`name  value` per line, INSCHEK's `.obf`). With a control file, all instruction files are
+read and observations the control file lists but no file produced are reported.
+
 ### diff — what changed
 
 ```
@@ -327,6 +377,12 @@ makepst validate tr13.xlsm            # a workbook with a BUILD sheet is built f
 | malformed prior equation; non-numeric right-hand side; `log()` used on a non-log parameter or vice versa | error |
 | `DERCOM` beyond the number of model command lines | error |
 | name longer than PEST's limit (12 parameter / 20 observation / 12 group; PEST++ allows 200) | warning |
+| **pestchek's rules** (from PEST 17's `pestchek.F` / `cheksub.F`): `PARCHGLIM` vocabulary and `absolute(n)` needing `absparmax(n)=`; log parameters factor-limited with positive values; factor-limited bounds of one sign and non-zero; `SCALE ≠ 0`; tied to itself, tied or parent with initial value 0; group `none` reserved; all parameters fixed/tied; `INCTYP` / `FORCEN` / `DERMTHD` vocabularies and their compatibility; split-column ranges; duplicate groups; `dum` as an observation name; prior weights, labels (≤ 20, not an observation name), duplicated parameters, all-zero factors, group `predict`; regularisation needs a `regul*` group, prediction exactly one `predict` observation; ~60 control-variable range and consistency rules (`RLAMFAC`, `PHIRATSUF`, `FACPARMAX`, `NPHISTP`, `RELPARSTP < RELPARMAX`, `EIGTHRESH`, `PHIMLIM < PHIMACCEPT < 1.2·PHIMLIM`, `WFMIN ≤ WFINIT ≤ WFMAX`, `UPTESTMIN`/`UPTESTLIM`, SVD vs AUI vs LSQR exclusivity, …) | error |
+| pestchek's warnings: derivative increment larger than a third of the range; initial value 0 with a relative increment; group with only fixed/tied parameters; log parameters with a non-relative increment; observation group listed but empty (dropped on write); `MAXSING` above the adjustable-parameter count; more than 300 adjustable parameters with `ICOV`/`ICOR`/`IEIG` on; `NOPTMAX 0` | warning |
+| PEST_HP-only control variables present (`WIN_MRUN_HOURS`, `UPTESTMIN`, `RRFSAVE`, …; plain PEST needs `/hpstart`); observation group whose weights are all zero | note |
+| template: parameter space narrower than 3 characters or containing a tab | error |
+| template: a value that cannot be written into its space as PEST writes numbers (`PRECIS` / `DPOINT` honoured), e.g. `1e-10` in five characters | error |
+| instruction file syntax: `l` / `t` integers, marker delimiters, `!` balance, `[name]n1:n2` order, `dum` in a fixed field, continuation `&` placement, `l` only at the start of a line, `t` and fixed columns moving left to right, unknown instructions — checked statically, without model output | error |
 | section in the `.pst` that makePst drops on read | warning |
 | template or instruction file missing; bad `ptf` / `pif` line | error |
 | parameter cited in no template; template citing an unknown parameter | error |
@@ -352,7 +408,7 @@ from?" after the fact:
 
 ```json
 {
-  "makepst": "0.1.0",
+  "makepst": "0.2.0",
   "command": "build",
   "argv": ["build", "tr13.pst", "regul", "--set_ctl_xls", "tr13.xlsm,CONTROL", "..."],
   "created": "2026-09-19T13:51:39-04:00",
@@ -423,7 +479,7 @@ update_workbook('book.xlsm', par='run.par', res='run.res', out='book_results.xls
 python -m pytest tests -q
 ```
 
-95 tests, no external data needed: a synthetic workbook in the real project layout
+106 tests, no external data needed: a synthetic workbook in the real project layout
 (`tests/data/demo.xlsx`, generated by `tests/make_fixture.py`) with a golden control file,
 `.par`, `.res` and IES ensemble files. They cover golden-file builds from Excel and CSV, the
 `read → write → read` identity, `dump → build` byte equality, workbook updates (multi-sheet
@@ -445,11 +501,13 @@ makepst/
   writer.py         Pst -> .pst text (+ dump.tpl)
   reader.py         .pst text -> Pst
   excel.py          sheets -> Pst; Pst -> workbook; results -> existing workbook
-  cli.py            init / validate / build / dump / update / parrep / diff
+  cli.py            init / validate / build / dump / update / parrep / diff / tempchek / inschek
   diff.py           semantic comparison of two Pst objects
   phi.py            objective function by group from residuals; IES realization phis
   pyemu_bridge.py   to_pyemu / from_pyemu
   checks.py         the validate report: table checks, template / instruction cross-checks, instruction interpreter
+  rules.py          pestchek's rules (parameters, groups, observations, prior information, control variables)
+  model_files.py    PEST's number writer, template filling, .obf files (tempchek / inschek)
   provenance.py     the <output>.manifest.json sidecar
   starter.py        the `init` workbook: control-variable descriptions, example rows, drop-downs
 examples/minimal/   the tutorial inputs

{makepst-0.1.0 → makepst-0.2.0}/makepst/__init__.py

@@ -3,9 +3,10 @@ try:                                        # the installed package's metadata (
     from importlib.metadata import version as _dist_version
     __version__ = _dist_version('makepst')
 except Exception:                           # a checkout run without installing
-    __version__ = '0.1.0'
+    __version__ = '0.2.0'
 
 from .excel import load_table, to_workbook, update_workbook
+from .model_files import fill_template, write_number
 from .provenance import Manifest
 from .pst import Pst, read_ensemble, read_obs_ensemble, read_par, read_res
 from .reader import from_text, read_pst
@@ -22,4 +23,5 @@ def from_pyemu(ppst):
     return _from(ppst)
 
 __all__ = ['Pst', 'read_pst', 'from_text', 'write_pst', 'to_text',
-           'load_table', 'to_workbook', 'update_workbook', 'read_par', 'read_res', 'read_ensemble', 'read_obs_ensemble', 'Manifest', '__version__', 'to_pyemu', 'from_pyemu']
+           'load_table', 'to_workbook', 'update_workbook', 'read_par', 'read_res', 'read_ensemble', 'read_obs_ensemble',
+           'fill_template', 'write_number', 'Manifest', '__version__', 'to_pyemu', 'from_pyemu']

{makepst-0.1.0 → makepst-0.2.0}/makepst/checks.py

@@ -11,8 +11,10 @@ import re
 
 import pandas as pd
 
+from .model_files import fit_problems, scaled_values
 from .pst import ADJUSTABLE, Pst, equation_params, is_number
 from .sections import ALL_SECTIONS
+from .writer import effective_control
 
 KNOWN_SECTIONS = {s.name for s in ALL_SECTIONS} | {
     'regularization', 'parameter groups', 'parameter data', 'observation groups', 'observation data',
@@ -173,9 +175,107 @@ def template_names(path):
     return [m.strip().lower() for m in re.findall(f'{d}(.*?){d}', body)]
 
 
+def template_problems(path):
+    """pestchek's template checks beyond the names: spaces narrower than 3 characters, tabs inside them."""
+    with open(path, errors='replace') as f:
+        head = f.readline().split()
+        body = f.read()
+    if len(head) != 2:
+        return []
+    d = re.escape(head[1])
+    out = []
+    for m in re.finditer(f'{d}(.*?){d}', body):
+        space = m.group(0)
+        if '\t' in space:
+            out.append(f'tab character inside the parameter space for {m.group(1).strip()!r}')
+        elif len(space) < 3:
+            out.append(f'parameter space for {m.group(1).strip()!r} is narrower than 3 characters')
+    return sorted(set(out))
+
+
 _INS_NAME = re.compile(r'!([^!\s]+)!|\[([^\]\s]+)\]|\(([^)\s]+)\)')
 
 
+def instruction_problems(path):
+    """pestchek's static instruction-file checks (syntax only; nothing is read from the model output)."""
+    with open(path, errors='replace') as f:
+        head = f.readline().split()
+        raw = f.read().splitlines()
+    if len(head) != 2 or head[0].lower() not in ('pif', 'jif'):
+        return ['first line must be "pif" or "jif" followed by the marker delimiter']
+    d = head[1]
+    if len(d) != 1 or d.isalnum() or d in '!&[]():':
+        return [f'illegal marker delimiter {d!r}']
+    tok_re = re.compile(re.escape(d) + '[^' + re.escape(d) + ']*' + re.escape(d) + r'|\S+')
+    out = []
+    first = True
+    col = 0                        # rightmost column pinned by t / [ ] / ( ) on the current output line
+    for li, ln in enumerate(raw, 2):
+        s = ln.strip()
+        if not s:
+            continue
+        continued = s.startswith('&')
+        if continued:
+            if first:
+                out.append(f'line {li}: the first instruction line cannot begin with the continuation character "&"')
+            s = s[1:].strip()
+        else:
+            if s.count(d) % 2:
+                out.append(f'line {li}: marker delimiter {d!r} not closed')
+            lead = s.split()[0].lower()
+            if not (lead.startswith(d) or re.fullmatch(r'l\d+', lead)):
+                out.append(f'line {li}: an instruction line must begin with "l", a marker or "&"')
+            col = 0
+        first = False
+        for ti, t in enumerate(tok_re.findall(s)):
+            low = t.lower()
+            if t.startswith(d):
+                if len(t) < 3:
+                    out.append(f'line {li}: marker has zero length')
+                elif '\t' in t:
+                    out.append(f'line {li}: tab character inside marker {t}')
+            elif re.fullmatch(r'l\d+', low):
+                if int(low[1:]) <= 0:
+                    out.append(f'line {li}: the integer after "l" must be positive')
+                if ti > 0 or continued:
+                    out.append(f'line {li}: a line advance ({t}) can only occur at the beginning of an instruction line')
+            elif re.fullmatch(r't\d+', low):
+                if int(low[1:]) <= 0:
+                    out.append(f'line {li}: the integer after "t" must be positive')
+                elif int(low[1:]) < col:
+                    out.append(f'line {li}: {t} moves backwards; a model output line must be read from left to right')
+                else:
+                    col = int(low[1:])
+            elif low == 'w':
+                pass
+            elif t.startswith('!'):
+                if not t.endswith('!') or t.count('!') != 2 or len(t) < 3:
+                    out.append(f'line {li}: "!" not balanced in {t}')
+                elif len(t) - 2 > 20:
+                    out.append(f'line {li}: observation name longer than 20 characters in {t}')
+            elif t[0] in '[(':
+                m = re.fullmatch(r'[\[(]([^\])]*)[\])](\d+):(\d+)', t)
+                if not m:
+                    out.append(f'line {li}: fixed / semi-fixed instruction must be [name]n1:n2 or (name)n1:n2, got {t}')
+                elif not m.group(1):
+                    out.append(f'line {li}: missing observation name in {t}')
+                elif m.group(1).lower() == 'dum':
+                    out.append(f'line {li}: "dum" is only allowed for non-fixed (!dum!) observations')
+                elif int(m.group(2)) == 0 or int(m.group(3)) < int(m.group(2)):
+                    out.append(f'line {li}: columns n1:n2 must be positive and increasing in {t}')
+                elif len(m.group(1)) > 20:
+                    out.append(f'line {li}: observation name longer than 20 characters in {t}')
+                elif int(m.group(2)) < col:
+                    out.append(f'line {li}: {t} starts left of column {col}; a model output line must be read from left to right')
+                else:
+                    col = int(m.group(3))
+            elif low.startswith('&'):
+                out.append(f'line {li}: "&" is only allowed at the beginning of a line')
+            else:
+                out.append(f'line {li}: illegal instruction {t!r}')
+    return out
+
+
 def instruction_names(path):
     """Observation names cited in an instruction file (lower-case, 'dum' excluded), in order."""
     with open(path, errors='replace') as f:
@@ -198,6 +298,9 @@ def check_files(pst: Pst, base_dir='.', outputs=False):
     rel = lambda p: os.path.join(base_dir, p)                              # noqa: E731
 
     par_names = set(pst.par['PARNME'])
+    ctl = effective_control(pst)
+    precis, dpoint = ctl.get('precis', 'single'), ctl.get('dpoint', 'point')
+    values = scaled_values(pst.par)
     cited = {}
     for tpl, model_in in pst.tpl:
         if not os.path.exists(rel(tpl)):
@@ -210,6 +313,12 @@ def check_files(pst: Pst, base_dir='.', outputs=False):
             continue
         if not names:
             warn(tpl, 'cites no parameters')
+        problems = template_problems(rel(tpl))
+        for problem in problems:
+            err(tpl, problem)
+        if not problems:                            # as TEMPCHEK would write it: does every value fit its space?
+            for problem in fit_problems(rel(tpl), values, precis, dpoint):
+                err(tpl, f'value cannot be written into its space: {problem}')
         unknown = sorted(set(names) - par_names)
         if unknown:
             err(tpl, f'cites parameters not in the control file: {_names(unknown)}')
@@ -236,6 +345,8 @@ def check_files(pst: Pst, base_dir='.', outputs=False):
             continue
         if not names:
             warn(ins, 'reads no observations')
+        for problem in instruction_problems(rel(ins)):
+            err(ins, problem)
         unknown = sorted(set(names) - obs_names)
         if unknown:
             err(ins, f'reads observations not in the control file: {_names(unknown)}')
@@ -267,7 +378,7 @@ def check_files(pst: Pst, base_dir='.', outputs=False):
         for tok in cmd.split()[:2]:
             looks_like_file = ('/' in tok or '\\' in tok or tok.lower().endswith(('.bat', '.exe', '.py', '.sh')))
             if looks_like_file and not os.path.exists(rel(tok)):
-                warn('model command line', f'{tok} not found relative to the control file')
+                warn('model command line', f'{tok} not found in {os.path.abspath(base_dir)}')
     return out
 
 
@@ -399,7 +510,8 @@ def _store(values, name, text, li):
 
 # ---------------------------------------------------------------------- driver
 def validate(pst: Pst, base_dir='.', pst_path=None, outputs=False):
-    findings = check_tables(pst)
+    from .rules import check_extra
+    findings = check_tables(pst) + check_extra(pst)
     if pst_path:
         findings += check_sections(pst_path)
     findings += check_files(pst, base_dir, outputs)