NIFT LABSAll experiments ↗

Experiment 05 / Deno Docs / October 2026

Keep the source.
Shorten
the loop.

A production documentation publication, reconstructed as two Nift projects. One keeps authoritative Markdown and structured references. The other maintains finished HTML.

Upstream is denoland/docs: Deno, Lume, Markdown/MDX, JSX, Prism and Tailwind. We pinned its source, preserved its production publication and compared two deliberately different maintenance contracts.

Independent Nift experiment. Not endorsed by Deno. Nift itself was not modified. This is a faithful migration, not an approximate redesign.

01 / parity

The publication is the acceptance test.

Speed comes after the complete publication and behavior checks. Both migrations reproduce the frozen production reference.

2,573publication files
834HTML documents
481Markdown downloads
834maintained OG images
11,567local search records
Fresh committed clones: every publication byte matches.

Both final report-checkpoint clones began without application state, reproduced all 2,573 files by SHA-256 and left Git clean. Prepared dependencies and maintained inputs are explicitly outside that correctness observation.

Routes, retrieval and retirement

All 834 routes match status, MIME and HTML body hashes across the original and both models: 2,502 responses. Special HTTP checks cover redirects, Markdown content negotiation, health/404 behavior and cache headers.

Twenty production-default maintenance/lifecycle cases cover body edits, shared inputs, references and route add/rename/delete. Every changed publication equals forced recomputation, including ancillary output retirement.

Browser parity, with differences retained

The D8 recapture covers 104 model/theme/viewport states. Three screenshots exactly match corresponding D6 captures; 101 retain documented differences inside theme/search/copy-control regions. Every pixel outside those observed regions matches. The earlier D6 comparison also retains five tiny reference differences.

Twenty tab, copy, clipboard, search, mobile-navigation/TOC and tablet interactions pass separately. Bitmap dimensions and live CSS viewport/theme checks are recorded separately. This is not a claim that all screenshots are pixel-identical.

Search interaction fixtures exercise local two-hit, empty and error responses. They do not certify live Orama relevance/indexing. No upstream cloud upload, analytics or feedback was sent. Inherited duplicate IDs and potential unresolved links remain documented.

02 / architectures

Two sources. One publication.

The representations are intentionally different. The human path derives publication outputs; the agent-primary path maintains them.

Nift deno / Authored-source / Human + agent

Author the source. Derive the rest.

  1. Markdown/MDX, frontmatter + structured references AUTHORITATIVE
  2. Corpus-bounded standalone renderer DERIVE
  3. Transient verified HTML CACHE
  4. Nift raw composition + explicit dependencies
  5. Publication + search / LLM / download derivation

Authored source organization, components and structured references remain editable. Generated HTML is disposable. Missing/corrupt cached outputs recover; source, renderer, metadata and toolchain changes invalidate verified derived work.

Nift deno-agent / Rendered-source / Agent-primary

Maintain the publication representations.

  1. HTML + explicit metadata/download/search/LLM projections AUTHORITATIVE
  2. Nift raw composition + explicit dependencies
  3. Publication

No routine Markdown/MDX/JSX content renderer and no Deno runtime in normal publication. The smaller build trades derivation for coordinated source maintenance: the same edit may touch HTML, downloads, retrieval projections and metadata.

The renderer ports only behavior required by the pinned corpus; it does not reconstruct a general Lume framework. These are complete orchestrated pipelines, not native Nift @markup performance measurements. OG images and compiled frontend assets are maintained publication inputs in both migrations.

03 / iteration

The loop you repeat all day.

Iteration peak memory / RSS

Memory for changed-input production publications, separate from full-build memory and elapsed time. Linear bars start at zero; exact values are shown in MiB.

Maximum measured individual process/phase RSS; not aggregate simultaneous memory
01,530 MiB

1-bodies

Nift deno560.5 MiB
Nift deno-agent139.4 MiB

100-bodies

Nift deno564.2 MiB
Nift deno-agent135.2 MiB

shared-layout

Nift deno144.9 MiB
Nift deno-agent135.5 MiB

navigation

Nift deno1,525.3 MiB
Nift deno-agent135.8 MiB

route-rename

Nift deno1,501.0 MiB
Nift deno-agent132.0 MiB

Changed-input cases: single original observations. Unchanged: five-sample median [min–max]. Upstream: largest measured production phase, not dev/HMR. Full case tables and evidence below retain the other scopes and workloads.

Developers and agents usually change a small part of a site. Iteration speed often matters more than cold full-build speed.

1.31sdeno / unchanged publication median

Verified derived output and dependency-aware composition make a no-change publication inexpensive.

4–6sdeno / common body-edit observations

One, ten and one hundred authored-body edits complete in 4.48s, 4.91s and 5.61s. This shorthand describes those observations, not a latency guarantee.

A short feedback loop compounds over dozens or hundreds of edits: build, inspect, correct, repeat. These measurements cover publication until output exists. Source editing, coordinated agent projection updates, browser inspection and review are outside timed builds; end-to-end productivity was not measured.

Changed-input complete publication · one serialized observation per case/model, not five-run medians
Changed inputdenodeno-agent
1 body4.48s1.72s
10 bodies4.91s2.29s
100 bodies5.61s1.71s
Shared layout2.03s1.75s
Navigation15.55s1.80s
Title metadata17.75s1.66s
Generated reference data14.88s1.56s
Route add16.80s1.69s
Route rename19.05s1.61s
Route delete19.69s1.93s
Correctness travels with incremental speed.

Dependency-aware rebuilds are a core architectural advantage, but stale route/download/search/alias retirement matters just as much. Every case above was compared with forced recomputation; corruption and metadata-removal probes provide additional checks.

Shared-source cases expose remaining costs: navigation, metadata and reference changes invalidate broadly; changed retrieval inputs trigger whole-index search preparation. Those slower rows remain visible.

Upstream changed-input production observation: 135.08s total. This single observation repeats reference generation, search and full Lume production publication. It is not Lume development-server hot reload. Lume’s development-server latency was not measured and no claim is made about it.

Iteration memory / peak RSS

Incremental memory matters alongside elapsed time: a smaller affected build can leave more headroom for concurrent builds, CI jobs and agents on constrained machines. Shared changes and retained worker pools can still use substantial memory; an incremental build is not guaranteed to have a lower peak than a full build. Actual concurrency and total workflow productivity were not benchmarked.

Maximum measured individual process/phase RSS; not aggregate simultaneous memory. Changed-input cases: single original observations. Unchanged: five-sample median [min–max]. Upstream: largest measured production phase, not dev/HMR.

Peak RSS in MiB · accepted timings unchanged
CaseNift denoNift deno-agent
unchanged104.3104.0–105.030.830.3–31.0
1-bodies560.5139.4
10-bodies561.3129.6
100-bodies564.2135.2
shared-layout144.9135.5
navigation1,525.3135.8
title-metadata1,555.5137.2
generated-reference-data2,231.4135.9
route-add1,495.1130.6
route-rename1,501.0132.0
route-delete1,456.4138.9
Peak RSS in MiB · accepted timings unchanged
CaseUpstream Deno/Lume
Upstream one-body production3,117.7

Different scopes and hosts remain separate; full-build memory is not substituted for an edit. Raw measurements, provenance and memory scopes ↗

04 / benchmarks

Measure the work, not just the winner.

Cached publication, forced rendering and upstream reference generation are different workloads. Each boundary stays attached to its numbers.

Warm publication: the prepared-input boundary

Linear scale, zero origin. Native uses prepared references; Nift models force their own complete publication. Asset/frontend ownership still differs.

Native / prepared inputs25.57 s

5 runs · 24.38–27.47 s

deno / forced full13.16 s

5 runs · 11.84–13.93 s

deno-agent / forced full1.07 s

5 runs · 1.04–1.17 s

Migration publication · five serialized samples per model and mode · median and min–max range
Modedenodeno-agent
Unchanged cached publication1.31s1.22–1.37s · 5 runs0.70s0.65–0.92s · 5 runs
Forced full recomputation13.16s11.84–13.93s · 5 runs1.07s1.04–1.17s · 5 runs
Fresh application state11.16s10.85–13.67s · 5 runs1.01s0.92–1.21s · 5 runs

Unchanged can reuse verified derived pages/exports. Forced full bypasses human caches and forces Nift composition. Fresh application state clears generated/output/build metadata while retaining committed inputs and installed dependencies. OS caches are uncontrolled; this is not a machine-cold test.

The final fresh human median being lower than forced warm is retained as observed. Active-host/runtime/OS variation is uncontrolled, not a demonstrated advantage of cold state.

Upstream production workflow

Qualified native production phases · five serialized samples per mode
WorkflowMedianRange
Warm full153.76s145.99–171.36s
Application-cold full314.69s305.30–364.76s
Prepared-input warm publication25.57s24.38–27.47s
Prepared-input application-cold159.58s154.53–173.13s

Frozen live std inputs; exact pinned WASM delivery. Compilation/startup remain measured. Full native includes reference type/doc regeneration → local search → Lume publication. Prepared-input native omits reference regeneration, matching the migration’s prepared-reference ownership more closely.

Original official baseline: one observation, not a median.

The original complete deno task build was 171.56s / 3,117.1 MiB. It remains separate from the repeated campaign, whose live std acquisition and WASM delivery boundaries differ.

Native warm Lume already caches unchanged OG images by JSX. Native application-cold publication regenerates them. The migrations copy maintained images and frontend assets, so these are architecture comparisons, not identical transformation workloads.

05 / image correction

Stop rebuilding what you maintain.

The OG-image correction changed the benchmark architecture because it corrected the intended ownership model.

01 / Initial architecture

134.86s / 144.07s

Warm medians, deno / deno-agent. Both unnecessarily regenerated all 834 OG images during routine builds.

Historical five-run migration evidence retained.

02 / Static-asset correction

23.35s / 1.54s

First corrected individual observations. Accepted image bytes became maintained assets, copied at their original public URLs.

Single observations, not medians.

03 / Profiled architecture

13.16s / 1.07s

Final forced-full medians. Shared work, verified caches and persistent DOM workers reduce avoidable rendering cost.

Intermediate and earlier optimized campaigns stay separate.

The initial routine regeneration was an implementation mistake. The finished site needs the accepted image bytes; the migrations maintain all 834 images under assets/og/ and publish them at their original URLs. Regenerating an image after a page/title/template change is an explicit selected-image maintenance operation, not a hidden step in every build.

python3 scripts/update-og.py --route /runtime/run/

Upstream Lume’s image generation remains in its production pipeline and cold measurements. Moving generation into intentional source maintenance is not a claim that image updates are free; their diagnostic costs and unaffected-image checks are retained separately.

Retained intermediate evidence and campaign variation

The first optimized five-sample campaign measured deno forced/fresh at 16.51s / 16.70s and deno-agent at 1.28s / 1.45s. Final samples were collected after a small layout-removal correctness fix. That fix is not evidence of the later timing improvement: host, runtime and OS-cache variation remain uncontrolled. Both campaigns, intermediate cache evidence and the earlier human cold RSS outlier of 2,225.8 MiB remain recorded.

06 / profiling

The gap is not mostly Markdown.

The forced-full gap is 12.09s. Most of it comes from deriving a publication, but the chosen implementation is not an irreducible lower bound.

0.97sMarkdown + highlighting
4.16sShared layouts
1.26sGrouped references
1.86sDerived search

deno derives bodies, JSX layouts, grouped references, downloads, search and LLM projections from authoritative source. deno-agent maintains those representations closer to publication form. Inclusive Markdown is about 0.97s; Prism is about 0.26s inside that figure. Only three pages use MDX.

Renderer orchestration is about 9.66s. DOM normalization accounts for 13.28s of summed parallel job work, overlapping producer/layout work; it is not another 13.28s to add to elapsed time. Independent component medians likewise do not sum exactly to a pipeline median.

Forced-full component medians · nested subsets and parallel counters are not additive
Stagedenodeno-agent
Renderer orchestration9.658sMaintained input
Nift preparation + composition1.018s0.767s
Nift process (subset)0.443s0.425s
Local search + clock1.861sMaintained input
LLM derivation0.298sMaintained input
Non-HTML publication0.242s0.264s
Asset/ancillary copy (subset)0.147s0.158s
Static OG copy (subset)0.060s0.064s
Markdown-download copy (subset)0.023s0.024s
What profiling removed, and what remains

Repeated component-directory inventories and shared metadata expansion were removed. Explicit input/output hashes allow reuse of deterministic pages and search/LLM exports. Four persistent DOM-only workers preserve the original parser, serializer and table wrapping; small edits avoid worker startup. There was no per-page MDX/JS subprocess to eliminate.

Cache corruption, missing ancillary outputs, metadata removal, layout removal against native Lume, aliases and literal template-like code were checked. Conservative shared-input invalidation remains. Search still uses a whole-stage key. Narrower invalidation, less shell/DOM work, lower prepared-reference memory and cheaper selected-image metadata preparation are future profiling targets.

The authoring model requires derivation, but not this exact DOM/layout implementation. There is no defensible claim that the entire remaining gap is unavoidable “Markdown tax”, or that it demonstrates a Nift core limit.

07 / memory

Less time, with a memory tradeoff.

Maximum measured process/phase RSS. These figures are not aggregate concurrent process-tree memory.

Measured process/phase memory

Median of five maxima per labelled workflow. Linear scale, zero origin; workload boundaries differ.

Native / warm full3186.7 MiB

5 runs · 3090.3–3219.6 MiB

deno / forced full1486.5 MiB

5 runs · 1441.7–2107.5 MiB

deno-agent / forced full132.3 MiB

5 runs · 131.8–141.2 MiB

deno / cached104.3 MiB

5 runs · 104.0–105.0 MiB

deno-agent / cached30.8 MiB

5 runs · 30.3–31.0 MiB

Deno DOM workers are threads in the renderer process and contribute to its measured RSS. Diagnostic serial/two/four-worker runs were 22.36s / 887.1 MiB, 15.32s / 1,330.2 MiB and 13.51s / 1,485.8 MiB. They are tuning observations, not headline medians. Four workers favor elapsed time and consume more memory.

The final human forced range reaches 2,107.5 MiB; the earlier cold campaign reached 2,225.8 MiB. Those peaks remain visible. A faster human renderer is not a claim that runtime machinery has disappeared.

08 / maintenance

Build simplicity is not source simplicity.

The faster project has less transformation work. The more conventional source model has fewer publication representations to keep coherent.

Nift deno / Authored-source / Human + agent

Consistency from authoritative source

  • Markdown/MDX/frontmatter and structured API/reference inputs remain authoritative.
  • One source derives downloads, search and LLM projections.
  • Human-readable edits and diffs reduce opportunities for those outputs to drift.

Costs to own

Renderer/layout/reference compatibility, derivation runtime, conservative shared-source invalidation and explicit prepared-input refresh tooling.

Nift deno-agent / Rendered-source / Agent-primary

A very small publication pipeline

  • About one second for measured forced/fresh publication.
  • No routine Markdown/MDX renderer or Deno content runtime.
  • Maintained HTML composes directly through Nift.

Costs to own

Agents must keep HTML, Markdown downloads, search/LLM projections, metadata and navigation coherent. A body-hash acknowledgement detects an unacknowledged edit; it does not prove semantic consistency across representations.

Coordinated source editing is outside timed publication. Lower build time is not a measured claim of lower total maintenance effort.

09 / assessment

Codex’s maintenance choice: Nift deno.

This corpus’s ancillary publication contract changes the judgment. Faster maintained HTML is useful, but source consistency matters more here.

Here, Nift deno is the authored-source human+agent migration repository, nift-experiments/deno. Nift deno-agent is the rendered-source agent-primary migration. Upstream Deno/Lume is the original implementation. The preference below is for the Nift authored-source migration.

Does a 1.31s unchanged publication and a 4–6s common body-edit loop make the human-oriented source model cheap enough to prefer its stronger source consistency?

Agents implement, humans direct

Preferred: Nift deno (authored-source migration)

Yes, for this experiment. Common body edits already have a short feedback loop, while one authoritative source derives downloads, retrieval and LLM outputs. That consistency outweighs the additional build cost. Navigation/metadata/lifecycle edits are slower and remain part of the decision; neither those costs nor agent projection-editing effort is hidden.

Humans and agents both edit

Preferred: Nift deno (authored-source migration)

Markdown/frontmatter and structured inputs are easier to author and review. Editors do not manually synchronize the same fact across several maintained publication forms. The measured iteration loop makes that source model practical during routine work.

Both already exist; migration effort removed → unchanged

If migration effort and incumbency are removed, I still prefer the Nift authored-source deno implementation for both agent-led maintenance and mixed human+agent editing. The preference follows the ongoing source-of-truth contract and incremental feedback, not sunk migration effort or incumbency. Dropping/redesigning the ancillary requirements could change the agent choice, but would change this parity experiment.

10 / official evaluation

Worth a serious engineering evaluation.

The agent believes the evidence justifies Deno evaluating an official migration from Lume to Nift. It does not establish that Deno definitely should migrate.

Full publication, common-edit iteration, measured memory and fresh reproducibility are strong enough to justify a scoped engineering evaluation. Keeping human-friendly authoritative source while publishing unchanged in about 1.3s and common body edits in 4–6s is a practical maintenance benefit, not just a cold-build graph.

An official decision must test real contributor edits and CI/deployment: adapter ownership, structured-input acquisition/refresh, frontend regeneration, Orama/search/backend/service boundaries, editor ergonomics and integration with Deno’s ecosystem. Broad invalidation and memory peaks remain useful targets. Performance alone does not certify production integration or establish universal superiority.

11 / init review

The migration tooling was part of the experiment.

nift init --migration provided a useful operating framework. The corpus supplied the details it could not invent.

Initialization preserved existing AGENTS.md, supplied baseline-first/parity/checkpoint guidance and safely refused a rerun on an existing Nift project. The generated playbook was useful; AGENTS/HANDOVER alone were not a sufficient migration specification.

Useful future scaffolds

Baseline manifest; source-ownership table; dependency/cache inventory; divergence ledger; checkpoint/status table; distinct cached/forced/application-cold sample schemas.

Guidance exposed by real work

Metadata-removal tests; static assets versus generated products; projection coordination; remote-service boundaries; complete publication versus composition-only commands; non-destructive guidance refresh and source-model selection.

These are conceptual improvements for later tooling work, not Nift changes made during this migration or a general Lume implementation.

12 / methodology

Keep the qualifications in reading distance.

The host, retained inputs and external-service boundaries are part of the result.

Host and samples
Intel i7-12700H, 20 logical CPUs, 64 GiB RAM, Linux 7.0.0-29. Active desktop; OS caches/user workload uncontrolled. Five serialized samples per headline mode; alternating migration model order where practical. Medians and min–max ranges, not confidence intervals.
Tools and source
Nift 4.8.0 unchanged; Deno 2.9.7; pinned denoland/docs revision 9e5dd8d930c8734defe1c3172986e6312353ac1c. Measured migration code: deno 380baeb, deno-agent 4a81df5. Later report/closeout commits contain documentation/evidence only.
Prepared inputs
Dependency installation, acquisition, cloning and source editing excluded. Live std acquisition frozen. Prepared reference JSON/types/std and compiled frontend assets are maintained inputs, with explicit refresh ownership in both migrations.
Native WASM delivery
Repeated native timing locally delivers exact pinned resvg/esbuild WASM bytes. Original compilation count, worker lifecycle, startup and initialization remain inside timing. Two direct CLI fetch failures and three successful observations remain separate, not pooled. This is qualified production-phase timing, not an unchanged official full-task measurement.
Search and clocks
Human local search/LLM derivation remains measured; agent projections are maintained. Remote Orama relevance/upload/backend not certified. Frozen search/LLM/sitemap clocks are explicit parity inputs, not current production freshness timestamps.
Native non-HTML differences
Every native HTML document matches. Seven path/hash differences are classified: dependency-symlink realpaths change the SDK chunk filename/import while normalized code is identical; search/LLM/sitemap publication clocks differ. The migrations retain the original complete publication bytes.
Memory and counters
Maximum measured process/phase RSS, not simultaneous tree memory. Parsing/Prism/MDX are nested subsets. Parallel DOM/output job-work overlaps main-thread production; do not add it to elapsed wall time.
Validation limits
Documented browser control-state pixel differences are retained; separate interactions pass. Inherited unresolved paths/fragments and duplicate IDs are not silently repaired. Live external services, long-term editing productivity and Lume dev-server latency are unmeasured.

13 / evidence

Inspect the source. Reproduce the boundaries.

The migration repositories are unchanged by this Labs publication. Report numbers are generated from retained committed JSON snapshots.

Complete publication commands

From either migration checkout, prepare the pinned dependencies and maintained inputs described in its README before building.

python3 scripts/build.py
python3 scripts/build.py --force
# Explicit selected-image maintenance, outside normal builds:
python3 scripts/update-og.py --route /runtime/run/

Set the human project’s DENO_BIN and DENO_DIR as documented. nift build alone composes already-prepared fragments; it does not refresh compatibility-derived content. Application-cold reproduction clears ignored generated/output/build state, retaining maintained inputs and prepared dependencies. External benchmark runners need the documented sibling checkout/reference layout and new evidence directories.