Nextjs Engine Latest Alpha (3.0.0-alpha.1)

Nextjs Engine — Latest Alpha

• Package version: 3.0.0-alpha.1
• Source commit: 6c79037
• SHA-256: 65ac37f978261efe618bf834d9a1d1a4ff3d8f9db8a728fe1a5616e2a138a18f
• Artifact: nextjs-engine-3.0.0-alpha.1-6c79037d0b8a4e207cdbe15bc26e2226664f086e.tgz
• This is a moving channel; the artifact URL remains commit-specific.

{
"schemaVersion": 1,
"packageName": "@kastrick/nextjs-engine",
"version": "3.0.0-alpha.1",
"track": "alpha",
"tag": "channel-alpha-latest",
"sourceBranch": "main-3",
"sourceCommit": "6c79037d0b8a4e207cdbe15bc26e2226664f086e",
"sha256": "65ac37f978261efe618bf834d9a1d1a4ff3d8f9db8a728fe1a5616e2a138a18f",
"assetName": "nextjs-engine-3.0.0-alpha.1-6c79037d0b8a4e207cdbe15bc26e2226664f086e.tgz",
"floating": true,
"summary": "Latest CI-checked Gen 3 Alpha build from main-3."
}

NE v2.6.2 — Runtime Stability

4dd7ba83 — Finalize v2.6.2 release notes and commit map

Short v2.6.2 commit summary

Commit	What got fixed
c82fe8b6	EngineScroll correctness. Fixed Timeline/Range normal #id targets, lazy/late-mounted elements, moving DOM boundaries, progressive viewport focus, physical velocity, resize invalidation, URL/hash handling, snapping, SSR safety, and subscriber crashes.
f1176ead ~ f4a92d32	Browser + React/Next stability. Hardened Transitions+ fallbacks, deterministic/hydration-safe Engine CSS, Overlay hydration, EngineNav route behavior, mobile viewport handling, dependencies, and React compatibility tests.
52e519b9	Transitions+ lifecycle bug. Fixed flushSync() being called from React effects. transitions.run() now works safely from effects, EngineScroll state, observers, subscriptions, timers, etc.
10f9ef1b ~ 8bb83404	Real-browser CI fixes. Stabilized the compatibility harness so actual Chromium, Firefox, and WebKit runtime behavior gets tested correctly.
2387320f ~ 8daade6b	EngineCanvas 120/144Hz fix. Added refresh-rate detection, ECFrameClock, display-aware adaptive DPR, stable elapsed timing, proper pause/resume timing, synchronized Canvas 2D default, 60/120/144Hz tests, dropped-frame tests, and CI. Main runtime patch: 22565507.
d6fc7ed7 ~ 9e766b5f	Public API + documentation finish. Documented the new Canvas timing behavior, exported frame timing types, and prepared the v2.6.2 release notes.

Tiny GitHub Release description

Next.js Engine v2.6.2 is a runtime stability patch focused on real browser and display behavior. It fixes EngineScroll target/focus correctness, lifecycle-safe Transitions+, React 19 hydration issues, Overlay/Nav/mobile edge cases, and EngineCanvas rendering on 60/90/120/144+ Hz displays. It also adds refresh-aware frame timing and real Chromium, Firefox, and WebKit regression testing.

Release range

v2.6.2
c82fe8b6 ~ 9e766b5f

NE v2.6.1 — React 19 & Hydration Stability

v2.6.1 is a stability-focused patch for the v2.6 generation of Next.js Engine.

This release fixes several React 19 / Next.js 16 issues around SSR hydration, generated Engine CSS, App Router navigation, Overlay portals, route matching, primitive styling, nested interactive markup, and runtime stylesheet behavior.

Highlights include:

• fixed Card/Button/Text style precedence so schema props correctly override primitive defaults;
• hardened Engine-generated CSS against SSR/client ordering mismatches;
• improved Dialog/Drawer/Popover hydration and live scroll-lock behavior;
• fixed reduced-motion hydration differences in EngineScroll;
• improved EngineNav behavior with Next.js rewrites and route-segment matching;
• unified internal Engine links with the Next.js routing pipeline;
• protected against invalid nested interactive/link markup;
• fixed Engine shimmer/keyframe collisions and HMR stylesheet duplication;
• improved React 19 stylesheet/font handling;
• hardened EngineShader hot-reload polling and listener isolation;
• expanded regression coverage for hydration and React/Next-specific failures.

v2.6.1 does not add another major subsystem — it makes the large v2.6.0 Shader + Transitions + Scroll + Overlay update significantly more reliable under real React 19 and Next.js 16 applications.

Full breakdown: docs/release/NE-v2-6-1.md

NE v2.6.0 — Shader, Motion, Scroll & Overlay

Release type: Feature release
Previous release: v2.5.0
Tag: Release-v2.6.0

Next.js Engine v2.6.0 is a major expansion of the v2 runtime. It introduces EngineShader, EngineTransitions+, and EngineOverlay as new first-class systems, turns EngineScroll into a much larger orchestration runtime, and substantially improves Canvas/SVG/3D rendering, styling, lazy loading, media behavior, diagnostics, and runtime performance.

The goal of this release is to make richer interfaces possible without forcing every application to rebuild shader, animation, scrolling, overlay, focus, rendering, and scheduling infrastructure by hand.

---

Highlights

• ✨ EngineShader — compiled .shed GPU surfaces with runtime variables, stages, scheduling, caching, and hot reload.
• 🎬 EngineTransitions+ — 20 configurable transition mechanics, shared-element morphing, programmatic transitions, and EngineNav integration.
• 📜 EngineScroll orchestration — timelines, ranges, point tracking/groups, snapping, crossing events, CSS bindings, scrubbing, and the new Director.
• 🪟 EngineOverlay — first-class dialog, drawer, and popover nodes with shared focus, Escape, stacking, portals, and positioning behavior.
• 🎨 EngineCanvas / EngineSVG / Engine3D upgrades — demand-driven RAF behavior, retained rendering improvements, Shader mode, topology fixes, and better GPU cleanup.
• ⚡ Runtime/performance work — scoped style collection, bounded resolver caching, pooled observers/listeners, lighter navigation, improved module splitting, and reduced idle work.
• 🧪 Stronger CI — dedicated Shader, Transitions+, Scroll, Overlay, style, APIStatic, SSR, type-check, and production-build regression coverage.
• 📚 Expanded official docs for every new visual/runtime system.

---

1. EngineShader — the new .shed graphics system

v2.6.0 introduces EngineShader (ESH), a compiled GPU-surface system designed for NE.

Shader source:

data/shader/public/**/*.shed

Generated runtime artifacts:

public/_static/shader/**/*.shed.dat
public/_static/shader/manifest.json

Application code uses logical shader names rather than generated hashes:

{
	type: "card",
	props: {
		shader: "aurora",
	},
}

.shed language

.shed is a small graphics/data-flow language rather than raw CSS or raw GLSL:

shader <= pixelAurora => [
	var <= speed => .55
	const <= pixelSize => 4

	render => [
		resolution => .25
		filter => nearest
	]

	before.aurora => [
		time <= system.time
		speed <= var.speed
		colors => [#071126 #5b21b6 #06b6d4]
	]

	after.pixel => [
		use => pixelate
		size <= const.pixelSize
	]
]

What EngineShader adds

• Runtime var values that schema/JSX can override.
• Compile-time const values.
• Runtime inputs for time, delta, frame, pointer, scroll, and viewport data.
• Four visual stages: before, render, after, and overlay.
• Current effects including gradients, aurora, noise, pixelation, palette reduction, dithering, and lightweight glow/bloom.
• Resolution scaling and linear / nearest filtering.
• Dead-pass and unused-uniform elimination.
• Automatic execution modes:
  • static — draw once, then idle;
  • event — redraw on relevant pointer/scroll/viewport changes;
  • animated — use the shared EngineShader RAF scheduler.
• Shared animation scheduling instead of one permanent RAF per shader.
• Manifest/artifact caching with stale-request race protection.
• Development hot reload for changed shader artifacts.
• Scheduler failure isolation so one bad shader callback cannot freeze the rest.

EngineCanvas Shader mode

<EngineCanvas
	shader={{
		src: "aurora",
		variables: {
			speed: .8,
			intensity: .65,
		},
	}}
	style={{ height: 420 }}
/>

When Shader mode is selected, EngineShader owns the surface instead of stacking a second canvas over a normal EngineCanvas renderer.

Read: ../engine-components/engineshader.md

---

2. EngineTransitions+ — 20 transition mechanics

The previous page-transition path has grown into EngineTransitions+, a first-class motion system for navigation, layout changes, and shared visual continuity.

Built-in transitions

fade       slide      zoom       morph      layout
reveal     wipe       split      curtain    pixel
dissolve   liquid     smear      depth      flip
page-turn  spring     scatter    rgb        portal

Simple usage:

cprop: {
	link: {
		transition: "portal",
	},
}

Configurable usage:

cprop: {
	link: {
		transition: {
			type: "portal",
			duration: 620,
			easing: "ease-out",
			origin: "pointer",
			config: {
				rotation: 8,
				blur: 5,
			},
		},
	},
}

Transition runtime additions

• Shared-element morphing.
• Layout transition support.
• Programmatic run(), push(), and replace() APIs.
• EngineNav and EngineLink integration.
• Normal internal links remain lightweight next/link navigation.
• Transition runtime is lazy-loaded only when animation is requested.
• Modifier-click/native navigation behavior is preserved.
• Reduced-motion preferences are respected.
• Unsupported browsers fall back to ordinary navigation.
• Active transitions can be interrupted.
• Legacy names remain available as aliases.

Important aliases include:

page-to-page     → fade
scale            → zoom
shared-morph     → morph
flip-layout      → layout
pixel-dissolve   → pixel
noise-dissolve   → dissolve
liquid-warp      → liquid
motion-smear     → smear
depth-push       → depth
card-flip        → flip
elastic-spring   → spring
scatter-assemble → scatter
chromatic-shift  → rgb

Read: ../engine-components/enginetransitions.md

---

3. EngineScroll — advanced orchestration

EngineScroll existed before v2.6.0, but this release expands it far beyond basic movement.

The shared runtime now covers named points, programmatic movement, timelines, ranges, active-point tracking, point groups, snapping, CSS bindings, crossing events, and multi-track orchestration.

Improved navigation

EngineScroll.move("#pricing", {
	align: "center",
	duration: 420,
	easing: "easeOutCubic",
});

EngineScroll.next({ duration: 280 });
EngineScroll.previous({ wrap: true });
EngineScroll.nearest();

Named point geometry supports start, center, end, and nearest alignment.

Timelines

const timeline = EngineScroll.timeline({
	start: "#hero",
	end: "#features",
	source: "current",
	easing: "linear",
});

Timeline frames expose normalized/raw progress, range state, direction, and velocity. Timelines support segments, keyframes, scrubbing/seeking, subscriptions, crossing/activity events, and direct CSS bindings.

New Scroll building blocks

• EngineScrollRange — reusable/cached boundary resolution.
• EngineScrollPointTracker — active/nearest semantic point tracking.
• Point groups — orchestrate related points together.
• EngineScrollSnap — optional point snapping through the same runtime.
• Crossing/activity events — react to thresholds and range state changes.

EngineScroll Director

The new Director coordinates many named timelines through one EngineScroll runtime subscription:

const director = EngineScroll.direct({
	hero: {
		start: "#hero",
		end: "#features",
		source: "current",
	},
	features: {
		start: "#features",
		end: "#pricing",
		source: "current",
	},
});

Director supports aggregate frames, per-track subscriptions, progress-only subscriptions, events, CSS bindings, seeking, sampling, interpolation, invalidation, and automatic subscription cleanup.

Read:

• ../engine-components/enginescroll.md
• ../engine-components/enginescroll-director.md
• ../engine-components/enginescroll-range.md
• ../engine-components/enginescroll-tracker.md
• ../engine-components/enginescroll-groups.md

---

4. EngineOverlay — Dialog, Drawer, and Popover

v2.6.0 adds a shared Overlay UI runtime with three first-class schema nodes:

dialog
drawer
popover

React exports:

EngineDialog
EngineDrawer
EnginePopover

Dialog

{
	type: "dialog",
	props: {
		triggerLabel: "Delete project",
		title: "Delete project?",
		description: "This cannot be undone.",
		actions: [
			{ label: "Cancel" },
			{ label: "Delete", variant: "danger", onClick: "deleteProject" },
		],
	},
}

Drawer

Supports left/right/top/bottom placement and configurable sizing.

Popover

Supports anchored placement, start/center/end alignment, viewport collision handling, automatic flipping, clamping, outside-click dismissal, and optional trigger-width matching.

Shared Overlay runtime

All three share:

• overlay stack management;
• top-overlay Escape ownership;
• focus discovery/trapping;
• initial focus and focus restoration;
• reference-counted body scroll locking;
• React portals;
• nested-overlay safety;
• backdrop dismissal rules;
• popover collision positioning;
• reduced-motion-aware transitions.

Overlay components are lazy registry split-points, so pages that never use Overlay do not eagerly load the component set.

Read: ../engine-components/engineoverlay.md

---

5. EngineCanvas, EngineSVG, and Engine3D

EngineCanvas

EngineCanvas now clearly supports t...

NE v2.5.0

Since v2.0.0

• 🐛 Bug fixes: 50+
• ⚡ Performance optimizations: 20+
• ✨ New features: 8+
• 🔧 API/runtime improvements: 25+
• 📦 Build & package improvements: 10+
• 📚 Documentation updates: 15+
• 🧪 New CI/regression checks: 6+

Highlights

• New APIStatic system for compiled .route endpoints
• Major EngineCanvas / 2D / 3D / SVG performance rewrite
• Major EngineManim performance + lifecycle improvements
• EngineScroll scheduler and navigation overhaul
• Hardened EngineBrowser SSR support
• Better lazy loading, observer pooling, media loading, and code splitting
• Large EngineAPIResolver correctness pass
• Automatic main → main-empty package synchronization
• New production build, APIStatic, SSR, package, and bundle-size CI checks

APIStatic

APIStatic can now:

• Compile data/endpoint/**/*.route into browser-loadable static endpoint modules
• Generate a route manifest automatically
• Use stable logical endpoint names without manually dealing with hashes
• Support multiple operations per endpoint
• Support run.query, run.body, run.input, and run.proxy
• Validate and coerce typed input schemas
• Support defaults and optional values
• Use normal async functions, fetch(), objects, arrays, and TypeScript syntax
• Return normal values or explicit response(...)
• Throw controlled error(...) responses
• Call configured backend bridges through proxy()
• Discover endpoints with APIStatic.names(), has(), and getEndpoints()
• Automatically watch and recompile .route files during development
• Preserve the last-known-good build if compilation fails
• Publish endpoint JS + manifest atomically
• Handle lexical scopes correctly, including normal variables like const response
• Safely support compact helper[...] call syntax without corrupting arrays, strings, comments, regex, or shadowed variables
• Integrate directly with EngineAPIResolver
• Run dedicated compiler/runtime regression tests in CI

Overall: v2.5.0 focuses heavily on performance, runtime correctness, APIStatic, and making NE's documented APIs actually match the implementation.

Next.js Engine v2.0.0 — Official Release Notes

The Next.js Engine v2.0.0 is a milestone release introducing comprehensive layout patching, custom runtimes for scroll and media, robust server-side analytics/compilers, and deeply integrated form-to-network orchestration.

This log tracks every major technical change, API specification, and operational update to guide your transition from previous versions.

📱 1. Server-Side Mobile Schema Patching (EngineMobile)

We have completely overhaul how the engine handles device-specific responsive layouts. Instead of traditional client-side media queries that cause layout shift, structural changes are now injected server-side.

• What Changed: * Introduced the EngineMobilePatcher which applies a MobileSchemaConfig patch list directly to your layout schema tree on the server before rendering.

• The desktop schema object is never mutated; patches apply non-destructively based on incoming request headers.

• Added a new stable targeting property name onto SchemaNode objects (e.g., name: "feature-grid") to let patches cleanly pinpoint targets within nested structures.

• Added top-level utility patch directives: "remove-all-prop" and "remove-all-cprop" to clean up desktop constraints before laying out mobile replacements.

• Hardware Detection: Added full client/server detection matching across 12+ hardware brands, including Apple, Samsung, Xiaomi, Huawei, Pixel, and generic Android units.

• 📚 Where to learn more: Read engine-components/enginemobile.md or jump to the EngineMobile — Server-Side Mobile Schema Patching breakdown inside DOCUMENT.md.

📜 2. The EngineScroll Runtime

Native browser scroll mechanisms and scroll-behavior: smooth have been fully replaced with a deterministic, requestAnimationFrame (RAF) based scroll runtime.

• What Changed: * createPage now automatically binds a global <EngineScrollProvider> context wrapper to every single page. You can now invoke the useEngineScroll() hook anywhere to fetch a uniform { move } navigation controller.

• Added EngineScrollPointManager to register named target semantic markers via a native point layout prop.

• The #-es? Protocol: Shipped a custom URL handler (EngineScrollURL) allowing deep-linking into specific scroll segments directly from URLs using parameters like move, offset, and duration (e.g., #-es?move=hero&duration=600). The runtime strips this string from the address bar cleanly via history.replaceState() once execution finishes.

• 📚 Where to learn more: Read engine-components/enginescroll.md or view the EngineScroll — Runtime Scroll System implementation guide inside DOCUMENT.md.

🌐 3. EngineBrowser Abstractions

The framework's client-side window utility footprint has been consolidated into five modular, SSR-safe execution pillars via EngineBrowser:

• Subsystems Added:

1. clipboard: Secure async clipboard reading, block validation, HTML copy configurations, and runtime permission status inquiries.
2. interact: Safe abstraction layers for native Web Notifications, Web Share hooks, modern File System Access permissions, Screen Wake Locks, Geolocation coordinates, and PWA system notification badges.
3. media: Simplified interface hooks mapping camera, microphone, and viewport stream capturing, built with strict hardware context release lifecycle loops.
4. speech: Built-in client bindings executing Text-to-Speech (TTS) pipelines and multi-language Speech-to-Text (STT) listeners.
5. network: Continuous snapshot monitoring and state subscription hooks tracking changes in active bandwidth (downlink), round-trip time (rtt), and device-enforced saveData data-saver policies.

• 📚 Where to learn more: Read engine-components/enginebrowser.md or look up EngineBrowser definitions inside DOCUMENT.md.

🛠️ 4. Static Schema Validation (schemaAnalyzer)

To eliminate runtime validation crashes during layout assembly, v2.0.0 incorporates a compiler-grade static validation engine.

• What Changed: The new schemaAnalyzer scans nested PageSchema arrays at build time and throws localized TypeScript-compiler-style diagnostic objects.

• Diagnostics Traced:

• E001 (Levenshtein Suggestion): Analyzes key strings and offers a "did you mean?" output for misspelled layout keys.

• E002 / E003 / E004: Catches missing structural properties, detects duplicate DOM id elements, and maps circular node layout references.

• Warnings (W001 - W005): Tracks a11y parameters (missing alt fields, broken labels) and marks performance bottlenecks like excessive DOM nesting depths.

• 📚 Where to learn more: Reference the full diagnostics error matrix table directly in the Static Schema Analyzer portion of DOCUMENT.md.

🔌 5. Multi-Tiered Declarative API Networking (EngineAPI)

Networking is now declared natively via build-integrated environment manifests, eliminating arbitrary client fetch definitions.

• What Changed: Introduces support for a centralized .api format managed inside a specialized .EngineAPIConfig/ workspace folder. This structure uses a fresh Webpack build plugin (engineApiPlugin.js) to parse text profiles down to lightweight optimized JSON structures directly during your Next.js application build stage.
• Security & Auth Integration: Standardizes data-transport protocols by native handling of multiple secure signature tiers including HMAC, JWT tokens, Bearer tokens, HTTP Basic authentication, and decentralized cryptographic PnP key verification pairs.
• Anti-Fingerprinting: Built-in network transport handlers actively sanitize outbound payloads, scrubbing header signatures like X-Engine-* or default framework markers to maintain privacy across servers.
• 📚 Where to learn more: Read engine-components/engineapi.md and check the networking guide inside DOCUMENT.md.

🧩 6. New Core Layout Primitives & Markdown Features

• The createComponent API: Enables the declaration of app chrome shells (such as top-tier persistent site structures) that accept layout nodes as standard runtime React slots inside the layout schema.

• Markdown Updates (EngineMarkdown): Added a filePath property to let the server read, parse, and process content blocks directly from local file structures on mount. Headings natively auto-generate clean string-slug hashes matching EngineScroll routing targets.

• Animations: Added textAnimation, blockAnimation, and millisecond staggered animation properties onto markdown schemas.

• New Nodes Shipped:

• EngineLink: Transition-aware hyper-links incorporating Next.js router mappings and native View Transitions hooks.

• EngineHero: Layout sections with "centered", "split", or "fullbleed" alignment, supporting custom parallax effects.

• EngineSuspense: Bound placeholders loading five responsive variations ("skeleton", "shimmer", "spinner", "pulse", "blur") alongside smart network timeout fallbacks.

• EngineForms: Standardized form validation tracking (form, input, textarea, checkbox) backed by automated data collection attributes.

• 📚 Where to learn more: Check out readme.md for createComponent, and see engine-components/enginemarkdown.md for content rendering properties.

🎨 7. The Graphics Layer (EngineCanvas & EngineManim)

• Pluggable Architecture: EngineCanvas now supports direct declaratively compiled scenes via a graphics layout prop. You can wire flat geometries using ecCircle, ecRect, or structural vector mapping via ecPath.
• Stylized Engines: Shipped native support for non-photorealistic visual shading tiers including "flat" cell shading styles.
• EngineSVG Integration: Includes dedicated vector compilation hooks (importSVG / exportSVG) capable of transmuting real vector document files directly into active ECMesh structures or rendering native crisp vector layout frames via a custom "svg" canvas mode engine.
• Fixes Implemented: Resolved an operational race condition where canvas initial setups fired before node physical attachments concluded inside the DOM. Fixed a frame freeze bug inside EngineManim caused by a faulty reliance on global clock counters instead of real frame delta parameters.
• 📚 Where to learn more: Read engine-components/enginecanvas.md and engine-components/enginemanim.md.

🐛 8. Technical Fixes & Cascade Performance Tweaks

• Hydration Fix (BUG-001): Rewrote the internal StyleCollector class to emit finalized style properties sequentially in a precise, deterministic layout order. Dev-only injection comments have been completely scrubbed from build streams to enforce byte-for-byte matching between server-generated and client-rendered style trees, resolving server mismatch crashes.
• Deduplication Engine (staticClass): Exposes a global utility method to compress raw CSSProperties objects down into shared, individual static CSS class allocations. Reused style footprints across multiple nodes map back to a singular identifier, radically cleaning up the overall DOM structure.
• CSS Scoping Hierarchy: Explicitly separated compiled stylesheet generation cascades into three clean evaluation passes: Global Layout rules, Group Rules, and strict Local overrides.
• Lazy Loading Enhancements: Video asset frames are fully deferred; the underlying DOM src string is dynamically withheld until layout components navigate to within 800px of the active client browser window viewport boundary. Images dynamically shift load limits using size dimensions (ranging from 400px to 800px).
• 📚 Where to learn more: Inspect staticClass — Deduplicated CSS Classes and the architecture section inside DOCUMENT.md.

Full Changelog: https://github.com/Kate-alt-69/nextjs-engine/com...

1.0.0 NE

1.0.0 Nextjs Engine ONLINE

** read README.md for the full documentation **

how to work with it

the NE engine is made for fast and smooth websites work without the need of optimizing EVERYTHING or anything lol

installation and work guild

• to compile the NE engine and YOUR website yo ucan use the following command

npm run clear;npm run build;npm run start
# ^^^

this command uses latest Powershell versions PWS7 install it with

winget install --id Microsoft.PowerShell --source winget

after that you can see your website being the /dist folder you can easily use Cloudflare Pages or other website hosting providers to use that static content