rack-server-pages 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abd39cdf92e58b58b6b5fe1d8ad5a19e3f971d83877d05526c7c9c724f2a24e3
-  data.tar.gz: 821cd0ad12aac479c687ae02b137a174919a463635422e74e996753c39045cc1
+  metadata.gz: e901e5e22aabc19775de43f94a34d3ae8a8b27a4469db4563f9e78052350cc38
+  data.tar.gz: b853d1e26f38fd0ecb79c53f51415d5e907a30ce5c7ab5b9e92e2697f1539897
 SHA512:
-  metadata.gz: db9d93a3135dc78b280365dc0bc6a84f15db54ac5eb5dcb292235f0ee1280f4268e6372817c868559533af4ecd696a015524c4f0b7880407d7ef2404aa4ce98a
-  data.tar.gz: 5698f4861e5dd6927df4b980f8a1bff9f5aa428b66b8136972f1ab739b45e424de74eb6a47e76738e8310720852448612c8826e6ec42ef2abd0b36690bb85a29
+  metadata.gz: c6f387713227b1a9d7495d8763b6817305882999484fb0318d25fccd610781ff70222138d740a86f9cc3d716a55b336db3b33285e6ef9fdf24f27c88c56d91e8
+  data.tar.gz: 8fac86b85b2a9bb9aef795faf61036c2479ffe83171c4a3d2e63f6f096d19eb882f8f5128c51abccb1a08011fc3e31a6dfd087cd1a31dfadd6aaf74f7feaf4c7

data/CHANGES.md

@@ -1,6 +1,28 @@
 CHANGES
 =======
 
+### [v0.3.0](https://github.com/migrs/rack-server-pages/releases/tag/v0.3.0) / 2026-10-25
+
+  * [Changes](https://github.com/migrs/rack-server-pages/compare/v0.2.1...v0.3.0)
+
+  * Feature
+    - Add content-versioned asset URLs, `static_etags` and `static_timestamps` (both enabled by default), and configurable static cache headers. See [UPGRADING](UPGRADING.md) for caching changes.
+
+  * Bugfix
+    - Detect the loaded Tilt template API rather than an incomplete namespace created by another dependency.
+
+  * Misc
+    - Enable line and branch coverage with SimpleCov and publish coverage to Coveralls from CI.
+    - Refresh the README, move its backlog into GitHub issues, and document rendering a template with `halt`.
+    - Modernize GitHub Actions and test Ruby 3.0 through 3.4 and 4.0 against Rack 2.2 and 3 with headless Firefox.
+
+### [v0.2.1](https://github.com/migrs/rack-server-pages/releases/tag/v0.2.1) / 2025-08-31
+
+  * [Changes](https://github.com/migrs/rack-server-pages/compare/v0.2.0...v0.2.1)
+
+  * Bugfix
+    - Stop using `Rack::Logger`
+
 ### [v0.2.0](https://github.com/migrs/rack-server-pages/releases/tag/v0.2.0) / 2024-10-19
 
   * [Changes](https://github.com/migrs/rack-server-pages/compare/v0.1.0...v0.2.0)

data/README.md

@@ -1,18 +1,20 @@
 Rack Server Pages
 =================
 
-Rack middleware and application for serving dynamic pages in very simple way.
-There are no controllers or models, just only views like a jsp, asp and php!
+Rack middleware and application for serving dynamic pages without controllers or models, using templates similar to JSP, ASP, and PHP. Requests map directly to files in your view directories. Built-in ERB works without extra runtime dependencies beyond Rack; Tilt and additional template engines are optional.
 
-<http://github.com/migrs/rack-server-pages>
+<https://github.com/migrs/rack-server-pages>
 
 [![Build Status](https://github.com/migrs/rack-server-pages/actions/workflows/test.yml/badge.svg)](https://github.com/migrs/rack-server-pages/actions/workflows/test.yml)
-[![Gem Version](https://badge.fury.io/rb/rack-server-pages.svg)](http://badge.fury.io/rb/rack-server-pages)
+[![Coverage Status](https://coveralls.io/repos/github/migrs/rack-server-pages/badge.svg?branch=master)](https://coveralls.io/github/migrs/rack-server-pages?branch=master)
+[![Gem Version](https://badge.fury.io/rb/rack-server-pages.svg)](https://badge.fury.io/rb/rack-server-pages)
 
 ## Features
 
 - Serving dynamic pages (default: ERB)
 - Serving static files
+- Content-versioned asset URLs with `asset_path`
+- Configurable static-file caching with content-based `ETag` headers and timestamp validation
 - No requirements (except Rack)
 - Tilt support (optional)
 - Include a partial template
@@ -25,12 +27,16 @@ There are no controllers or models, just only views like a jsp, asp and php!
 
 ## Requirements
 
-- [Ruby](http://ruby-lang.org/) >= 2.2.2
-- [Rack](http://github.com/rack/rack)
+- [Ruby](https://www.ruby-lang.org/)
+- [Rack](https://github.com/rack/rack)
+
+CI tests Ruby 3.0 through 3.4 and 4.0 against Rack 2.2 and 3, including browser integration tests with headless Firefox. Selenium manages the browser driver automatically.
+
+The test suite collects line and branch coverage with SimpleCov before loading the library, including unexecuted files under `lib/`. Run `bundle exec rake spec` and open `coverage/index.html` to inspect the local report. CI publishes `coverage/.resultset.json` to Coveralls from the Ruby 4.0 / Rack 3 job only, so compatibility jobs do not overwrite each other's reports. Coverage output is ignored by Git.
 
 ## Install
 
-[RubyGems](http://rubygems.org/gems/rack-server-pages) available
+Available on [RubyGems](https://rubygems.org/gems/rack-server-pages):
 
 ```
 gem install rack-server-pages
@@ -83,30 +89,30 @@ And same as above.
 
 ## Template bindings
 
-- CoreHelper
-  - layout(file)
-  - partial(file)
-  - redirect(target, status=302) (same as [Sinatra](http://www.sinatrarb.com/intro#Browser%20Redirect))
-  - halt(\*args) (same as [Sinatra](http://www.sinatrarb.com/intro#Halting))
-  - url(path)
-
-- [Rack::Request](http://rack.rubyforge.org/doc/Rack/Request.html)
-  - request
-  - env
-  - params
-  - session
-  - cookies
-  - logger
-
-- [Rack::Response](http://rack.rubyforge.org/doc/Rack/Response.html)
-  - response
-  - headers
-  - set\_cookies
-  - delete\_cookie
-
-- [ERB::Util](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/erb/rdoc/ERB/Util.html)
-  - h (alias for: html\_escape)
-  - u (alias for: url\_encode)
+- `CoreHelper`
+  - `layout(file)`
+  - `partial(file)`
+  - `redirect(target, status=302)` (same as [Sinatra](http://www.sinatrarb.com/intro#Browser%20Redirect))
+  - `halt(*args)` (same as [Sinatra](http://www.sinatrarb.com/intro#Halting))
+  - `url(path)`
+  - `asset_path(path)`
+
+- [`Rack::Request`](https://www.rubydoc.info/gems/rack/Rack/Request)
+  - `request`
+  - `env`
+  - `params`
+  - `session`
+  - `cookies`
+
+- [`Rack::Response`](https://www.rubydoc.info/gems/rack/Rack/Response)
+  - `response`
+  - `headers`
+  - `set_cookies`
+  - `delete_cookie`
+
+- [`ERB::Util`](https://docs.ruby-lang.org/en/master/ERB/Util.html)
+  - `h` (alias for: `html_escape`)
+  - `u` (alias for: `url_encode`)
 
 ## Configurations
 
@@ -144,21 +150,148 @@ run Rack::ServerPages.new { |config|
 
 ### Options
 
-- view\_path
-  - Views folders to load templates from.
-  - default: [views, public]
+#### `view_path`
+
+Sets the directories searched for templates and static files, in priority order. Accepts one directory or an array; the first matching file is used.
+
+Default: `['views', 'public']`.
+
+```ruby
+config.view_path = ['site/views', 'site/public']
+```
+
+#### `effective_path`
+
+Limits file serving to a URL prefix and removes that prefix when resolving files. Requests outside the prefix fall through to the downstream or fallback application.
+
+Default: `nil` (no prefix).
+
+```ruby
+config.effective_path = '/pages'
+```
+
+This serves `/pages/about.html` from `about.html` under a configured `view_path` directory.
+
+#### `default_charset`
+
+Sets the default charset in rendered template responses' `Content-Type` header. Does not convert file contents or change static-file headers.
+
+Default: `'utf-8'`.
+
+```ruby
+config.default_charset = 'utf-8'
+```
+
+#### `cache_control`
+
+Sets the default `Cache-Control` response header for rendered templates, including generated CSS. A header explicitly set by a template or filter takes precedence. Static files use `static_cache_control` instead.
+
+Default: `nil` (no policy added).
+
+```ruby
+config.cache_control = 'private, no-store'
+```
+
+This prevents caching pages containing sensitive information.
+
+#### `static_cache_control`
+
+Sets the `Cache-Control` response header for static files such as CSS, JavaScript, and images. Rendered templates, including generated CSS, use `cache_control` instead.
+
+Default: `nil` (no policy added).
+
+```ruby
+config.static_cache_control = 'public, no-cache'
+```
+
+This allows caching but requires revalidation before reuse.
+
+#### `static_etags`
+
+Adds a content-based `ETag` response header to static files by hashing each file with SHA-256 on each request. A matching `If-None-Match` returns an empty `304` for `GET`/`HEAD` and takes precedence over `If-Modified-Since`.
+
+Default: `true`.
+
+```ruby
+config.static_etags = false
+```
+
+This disables content hashing, `ETag` generation, and `ETag` validation without disabling `static_timestamps` or `asset_path`.
+
+#### `static_timestamps`
+
+Honors `If-Modified-Since` on static requests using Rack's timestamp-based conditional handling, unless enabled `static_etags` validation takes precedence.
+
+Default: `true`.
+
+```ruby
+config.static_timestamps = false
+```
+
+This ignores `If-Modified-Since` when deployment timestamps are unreliable. The `Last-Modified` response header and `static_etags` validation are unaffected.
+
+#### `failure_app`
+
+Sets a fallback Rack application for requests that do not resolve to a template or static file. When used as middleware, the downstream application takes precedence over this setting.
+
+Default: `nil` (uses the built-in `404` response when no downstream application is supplied).
 
-- effective\_path
-  - default: nil
+```ruby
+config.failure_app = ->(_env) { [404, { 'content-type' => 'text/plain' }, ['Page not found']] }
+```
+
+#### `show_exceptions`
+
+Controls whether template-rendering errors are raised to the caller or handled as a `500` response with `on_error` filters. Does not control a built-in error page.
+
+Default: `nil` (raises when `RACK_ENV` is unset or `'development'`; handles errors in other environments).
+
+```ruby
+config.show_exceptions = false
+```
+
+This handles template errors instead of raising them.
+
+### Versioned assets and browser caching
+
+Content-based `ETag` validation and versioned asset URLs work independently. With `static_etags = true` (the default), ordinary URLs such as `/styles.css` receive `ETag` headers and support `If-None-Match` without using `asset_path`. However, validators only help when the browser makes a request; they cannot prevent reuse of an asset that the browser considers fresh. `asset_path` changes the URL when the file contents change, so a browser fetching fresh HTML requests the new asset URL instead of reusing the old one. Use both for stronger stale-asset protection.
+
+Use `asset_path` instead of a fixed local asset URL in templates:
+
+```erb
+<link rel="stylesheet" href="<%= h asset_path('/styles.css') %>">
+<script src="<%= h asset_path('/scripts/app.js') %>"></script>
+<img src="<%= h asset_path('/img/logo.png') %>" alt="Logo">
+```
 
-- default\_charset
-  - default: utf-8
+The helper adds a SHA-256 content fingerprint, for example `/styles.css?v=...`. Changed file contents produce a new URL even when a deployment preserves file timestamps and sizes. Existing query parameters and fragments are preserved, and an existing `v` parameter is replaced. Paths are relative to the configured view paths; application mounts (`SCRIPT_NAME`) and `effective_path` are included automatically. Missing files raise `Errno::ENOENT`; external URLs and parent-directory traversal are rejected.
 
-- cache\_control
-  - default: nil
+Configure browser revalidation explicitly:
+
+```ruby
+use Rack::ServerPages do |config|
+  config.cache_control = 'private, no-cache'
+  config.static_cache_control = 'public, no-cache'
+end
+```
 
-- failure\_app
-  - default: nil
+Both settings default to `nil`, preserving the existing cache-policy defaults. `no-cache` permits storage but requires revalidation before reuse; use `private, no-store` instead for templates containing sensitive account or payment information. These settings do not change cache headers on the downstream application.
+
+By default, static responses include content-based `ETag` headers, hashing the file on each request. Matching `If-None-Match` requests return an empty `304` response. When both validators are present, `If-None-Match` takes precedence over `If-Modified-Since`, so a changed file is returned for an old `ETag` even if its modification time is unchanged. Requests with only `If-Modified-Since` retain Rack's timestamp-based conditional handling.
+
+Set `config.static_etags = false` to disable content hashing and content-based `ETag` validation. With the default timestamp-validation setting, this restores Rack's original static-file conditional handling. `static_cache_control` still applies, and `asset_path` remains available independently. See [UPGRADING](UPGRADING.md) when updating from an earlier release.
+
+`static_timestamps` also defaults to `true`. Set `config.static_timestamps = false` to ignore timestamp-based request validation when deployment timestamps are unreliable. This does not remove the `Last-Modified` response header or disable `ETag` validation. Set both options to `false` to disable both conditional checks.
+
+Use the helper for local images, fonts, icons, and other assets too. For URLs inside CSS, rename the stylesheet to `styles.css.erb` and render those references explicitly:
+
+```erb
+.hero { background-image: url("<%= asset_path('/img/background.svg') %>"); }
+```
+
+Continue linking to `/styles.css` through `asset_path`. The fingerprint identifies the selected source file; generated CSS must also use `cache_control = 'private, no-cache'` so changes to a referenced image are picked up even when the CSS template itself has not changed. Referenced files are not rewritten automatically, and no build pipeline is needed.
+
+Do not set `immutable` or a long freshness lifetime for these query-versioned URLs: the middleware serves the current file, not an archive of old versions. This mechanism does not force an already-open page to reload; the new URLs take effect when it fetches fresh HTML.
 
 ### Helpers
 
@@ -174,7 +307,7 @@ use Rack::ServerPages do |config|
 end
 ```
 
-in view file (erb)
+in view file (`.erb`)
 
 ```erb
 <%= three_times('blah') %>
@@ -212,7 +345,7 @@ end
 
 ### Filters
 
-with before/after block
+with `before`/`after` block
 
 ```ruby
 use Rack::ServerPages do |config|
@@ -221,7 +354,7 @@ use Rack::ServerPages do |config|
   end
 
   config.after do
-    logger.debug 'xxxx'
+    Logger.new($stdout).debug('xxxx')
   end
 end
 ```
@@ -231,7 +364,7 @@ with procs
 ```ruby
 proc1 = proc { @name = 'Jonny' }
 proc2 = proc { @age = 24 }
-proc3 = proc { logger.debug 'xxxx' }
+proc3 = proc { Logger.new($stdout).debug('xxxx') }
 
 use Rack::ServerPages do |config|
   config.before proc1, proc2
@@ -239,7 +372,7 @@ use Rack::ServerPages do |config|
 end
 ```
 
-if you define before/after method in helper module, it will be treated as filters
+if you define a `before`/`after` method in a helper module, it will be treated as a filter
 
 ```ruby
 module SampleHelper
@@ -263,9 +396,26 @@ in view file
 <%= three_times(@title) %>
 ```
 
+### Rendering a template with `halt`
+
+`partial` returns a rendered string, so pass its result to `halt` as the response body. For example, create `views/forbidden.html.erb`:
+
+```erb
+<h1><%= 'Forbidden' %></h1>
+```
+
+Inside a `before` filter, helper, or template, return that page with the desired status and content type:
+
+```ruby
+halt 403, { Rack::CONTENT_TYPE => 'text/html; charset=utf-8' }, partial('views/forbidden.html')
+```
+
+Place the call inside your existing validation or authorization check. `partial` takes a filesystem path relative to the working directory, or an absolute path; it does not search `view_path` automatically. Omitting the final `.erb` suffix lets it find the template. `halt` skips normal page rendering, so automatic layouts are not applied to this response. The example works with both built-in ERB and Tilt.
+
 ## Tilt support
-[Tilt](http://github.com/rtomayko/tilt) is generic interface to multiple Ruby template engines.
-If you want to use Tilt, just `require 'tilt'` and require template engine libraries that you want.
+[Tilt](https://github.com/rtomayko/tilt) is a generic interface to multiple Ruby template engines. To use it, add Tilt and the desired engines to your dependencies, then explicitly require them:
+
+Tilt is selected only when its template lookup API is available. A `Tilt` namespace created by another dependency does not enable it or force it to load. Loading Tilt later enables it for subsequent requests unless you have explicitly disabled it with `Rack::ServerPages::Template.use_tilt(false)`.
 
 ```ruby
 require 'rack-server-pages'
@@ -274,7 +424,12 @@ require 'rdiscount' # markdown library
 run Rack::ServerPages
 ```
 
-or put your `Gemfile`
+If your application uses `Bundler.require`, the equivalent `Gemfile` entries are:
+
+```ruby
+gem 'tilt', require: 'tilt'
+gem 'rdiscount', require: 'rdiscount'
+```
 
 ### [Markdown](http://daringfireball.net/projects/markdown/)
 
@@ -469,21 +624,13 @@ At first, create sample file: `public/hello.erb` or `views/hello.html.erb`
 
 ### Rails
 
-Add to `config/environment.rb` (Rails2) or `config/application.rb` (Rails3)
+Add the middleware inside your application configuration in `config/application.rb`:
 
 ```ruby
 config.middleware.use Rack::ServerPages
 ```
 
-And run
-
-Rails2
-
-```
-script/server
-```
-
-Rails3
+Start Rails:
 
 ```
 rails s
@@ -521,15 +668,15 @@ ruby sinatra_sample.rb
 
 ### Customize file extension associations
 
-#### e.g. .php as ERB
+#### e.g. `.php` as ERB
 
-ERBTemplate (default)
+`ERBTemplate` (default)
 
 ```ruby
 Rack::ServerPages::Template::ERBTemplate.extensions << 'php'
 ```
 
-TiltTemplate (see. [Template Mappings](http://github.com/rtomayko/tilt))
+`TiltTemplate` (see. [Template Mappings](http://github.com/rtomayko/tilt))
 
 ```ruby
 Tilt.register Tilt::ERBTemplate, 'php'
@@ -543,25 +690,22 @@ And create `public/info.php` :)
 
 <http://localhost:9292/info.php>
 
-## Demo site
+## Development
+
+Clone the repository and install its development dependencies. RedCloth and BlueCloth are legacy optional test engines; the C17 build options let them compile when Ruby defaults to C23:
 
-<http://rack-server-pages.heroku.com/>
+```sh
+bundle config set --local build.RedCloth --with-cflags=-std=gnu17
+bundle config set --local build.bluecloth --with-cflags=-std=gnu17
+bundle install
+MOZ_HEADLESS=1 bundle exec rake
+```
 
-## ToDo
+The default task runs lint and the full suite. Browser examples require Firefox; Selenium manages its driver. Run `bundle exec rake spec` for only the tests.
 
-### Implements
-- Static file generator (for designer)
+Run the included application with `bundle exec rackup` and visit <http://localhost:9292/> or <http://localhost:9292/examples/> for local examples. There is no maintained hosted demo.
 
-### Tasks
-  - Tutorials
-    - for PHP user
-    - for Designer
-    - for Windows user
-  - More documents
-    - Deployment using apache / passenger / nginx
-  - Complete Tilt examples
-  - Philosophy
-  - Benchmark
+See [RELEASING](RELEASING.md) for the maintainer release process.
 
 ## License
 

data/RELEASING.md

@@ -0,0 +1,79 @@
+# Releasing Rack Server Pages
+
+Release bug fixes frequently, features less frequently, and breaking changes rarely.
+
+## Release
+
+Start from a clean, up-to-date canonical checkout on `master`. Confirm that `origin` points to `migrs/rack-server-pages`, the version in `lib/rack-server-pages/version.rb` matches the next heading in [CHANGES.md](CHANGES.md), and the version has not already been tagged or published to RubyGems.
+
+```sh
+git switch master
+git pull --ff-only origin master
+git status --short
+```
+
+Run lint and the complete test suite with Firefox available. Selenium manages its driver; use headless mode locally. See [Development](README.md#development) for dependency setup.
+
+```sh
+MOZ_HEADLESS=1 bundle exec rake
+```
+
+Also run the suite against Rack 2.2. The `RACK_VERSION` selector must be set when resolving dependencies and running tests:
+
+```sh
+RACK_VERSION='~> 2.2' bundle update rack rackup
+RACK_VERSION='~> 2.2' MOZ_HEADLESS=1 bundle exec rake spec
+```
+
+Return to the default Rack 3 dependencies afterward:
+
+```sh
+bundle update rack rackup
+```
+
+Review [UPGRADING.md](UPGRADING.md) for behavior changes. Replace `Next` in the release heading in `CHANGES.md` with the current date, preserving the existing `YYYY-MM-DD` format. Commit and push the release preparation:
+
+```sh
+git add CHANGES.md
+git commit -m "Preparing for release, 0.3.0."
+git push origin master
+```
+
+Wait for the release commit's [GitHub Actions](https://github.com/migrs/rack-server-pages/actions) checks to pass across the full Ruby/Rack matrix and lint. A successful build for a different commit is not sufficient.
+
+Publishing requires a maintainer's RubyGems credentials and may require a fresh one-time password (OTP). For an agent-assisted release, request the OTP immediately before publishing, after validation and CI complete. Never commit or log credentials or OTPs. With `OTP` holding a freshly supplied code:
+
+```sh
+GEM_HOST_OTP_CODE="$OTP" bundle exec rake release
+unset OTP
+```
+
+Bundler builds the gem in `pkg/`, creates the version tag, pushes the commit and tag, and publishes the gem. Verify that the remote tag points to the release commit and RubyGems lists the expected version. If a step fails, inspect what completed before retrying; never move a published release tag or overwrite a published version.
+
+Create a GitHub release from the tag, using the corresponding changelog entry as release notes and linking to the upgrade guide for behavior changes:
+
+```sh
+gh release create v0.3.0 --verify-tag --title "v0.3.0" --notes-file /path/to/release-notes.md
+```
+
+## Prepare the Next Version
+
+Increment the patch version in `lib/rack-server-pages/version.rb`, then add a new `Next` section at the top of `CHANGES.md`, updating both its release and comparison links:
+
+```markdown
+### [v0.3.1](https://github.com/migrs/rack-server-pages/releases/tag/v0.3.1) / Next
+
+  * [Changes](https://github.com/migrs/rack-server-pages/compare/v0.3.0...v0.3.1)
+
+  * Feature
+
+  * Bugfix
+
+  * Misc
+```
+
+```sh
+git add CHANGES.md lib/rack-server-pages/version.rb
+git commit -m "Preparing for next development iteration, 0.3.1."
+git push origin master
+```

data/UPGRADING.md

@@ -0,0 +1,23 @@
+# Upgrading
+
+## 0.2.x to 0.3.0
+
+### Static-file caching changes by default
+
+`static_etags` defaults to `true`. Static-file responses now include an ETag derived from a SHA-256 hash of the file contents. Matching `If-None-Match` validators return an empty `304` response for GET and HEAD. When both `If-None-Match` and `If-Modified-Since` are present, the ETag takes precedence: an old ETag produces a full response even if the file's timestamp is unchanged.
+
+Requests with only `If-Modified-Since` retain Rack's timestamp-based conditional handling, including `304` responses for matching timestamps. Such requests still rely on accurate modification times; adopt content-versioned asset URLs for protection against deployment tools that preserve or normalize timestamps.
+
+The file is read and hashed on each static request, adding disk and CPU work. To restore Rack's original static-file conditional handling without this content hashing, disable the option:
+
+```ruby
+use Rack::ServerPages do |config|
+  config.static_etags = false
+end
+```
+
+This omits content-based ETags and, with the default timestamp-validation setting, delegates conditional handling entirely to Rack. `static_cache_control` still applies when configured. Template responses and downstream applications are unaffected by this option.
+
+### Optional timestamp-validation opt-out
+
+`static_timestamps` defaults to `true`, preserving Rack's timestamp-only conditional responses. Set `config.static_timestamps = false` to ignore `If-Modified-Since` on static requests when modification times are unreliable. The `Last-Modified` response header is still emitted, and matching ETags can still produce a `304`. The switches are independent: set both `static_etags` and `static_timestamps` to `false` to disable both conditional checks. Neither option affects template responses or downstream applications.