@nifrajs/cli 2.14.1 → 3.1.0

package/docs/llms-full.txt

@@ -320,7 +320,7 @@ renders in its place, wrapped by the layouts at/above that segment, at status 50
 non-hydrated). On the **client** - a render error during navigation/interaction is caught by
 the nearest boundary, which renders `_error` in place (all five adapters). It
 receives the serialized error as `{ data: { name, message } }` (never the
-stack); a thrown `Response` (e.g. a guard `redirect`) passes through.
+stack); a thrown control-flow value (e.g. a guard `redirect`) passes through.
 
 ```ts
 routes/
@@ -1607,6 +1607,8 @@ Node against the outcome's plain header record on the **direct socket writer**,
 ever materializing Web `Request`/`Response` objects:
 
 ```ts
+import { responseObserver } from "@nifrajs/core/response-observer"
+import { server } from "@nifrajs/core/server"
 import type { Middleware } from "@nifrajs/core/server"
 
 // ONE implementation, fast on every runtime: on Bun/Deno it mutates the
@@ -1619,6 +1621,8 @@ export function serverName(value: string): Middleware {
     },
   }
 }
+
+const app = server().use(responseObserver()).use(serverName("nifra"))
 ```
 
 Why this matters on Node: a full `onResponse(res: Response)` hook needs real Web
@@ -2799,9 +2803,10 @@ createWebApp({ /* … */ api: sessions })                  // inject the manager
 
 ### Guard a route
 
-`requireSession` / `requireUser` throw a `Response` (a 302 to
-`redirectTo`, or a 401) when the session is missing - Nifra returns a thrown Response
-as-is, so the guard short-circuits the loader.
+`requireSession` / `requireUser` throw a `status(...)` render
+(a 302 to `redirectTo`, or a 401) when the session is missing - Nifra renders a
+thrown control-flow value as-is, so the guard short-circuits the loader. It is plain data, not
+a `Response`: same bytes on the wire, on the lane an ordinary return takes.
 
 ```ts
 // doc-check: skip - fragment: `api` is the session manager createWebApp injected (see setup above).
@@ -3422,6 +3427,28 @@ app.ws("/chat", {
 })
 ```
 
+### Optional outbound validation
+
+`sendSchema` is type-level by default: it documents and types what the client
+receives with no runtime cost. Set `validateSend: true` to check server-sent JSON
+text and UTF-8 binary frames before the native socket sends them. Invalid frames and async
+validators fail closed and route a diagnostic to `error` when present. This is a
+contract check for your own output, not an inbound security boundary; the flag requires a
+`sendSchema` and is intentionally off by default.
+
+```ts
+// doc-check: skip - illustrative: outbound contract on an existing app.
+import { t } from "@nifrajs/schema"
+
+app.ws("/events", {
+  sendSchema: t.Object({ kind: t.Literal("ready"), id: t.String() }),
+  validateSend: true, // opt in; default remains type-level only
+  open(ws) {
+    ws.send(JSON.stringify({ kind: "ready", id: "evt-1" }))
+  },
+})
+```
+
 ### Pub/sub - app.publish
 
 `ws.subscribe(topic)` joins a topic; `app.publish(topic, data)`
@@ -4654,9 +4681,9 @@ global state; a second copy nulls it out and every hook throws.
 
 Nifra **dedupes React** in both the production build and the Vite dev server, so
 the framework itself won't load two copies. The usual culprit is a
-**`file:`-linked package** (a local component library you
-`bun link` or reference with `file:../lib`) that bundles its own React in
-its own `node_modules`:
+**`file:`- or `link:`-linked package** (a local component
+library you `bun link` or reference with `link:../lib`) that bundles its
+own React in its own `node_modules`. Fix the install first, if you can:
 
 -
 Make React a **peer dependency** of the linked package (not a regular
@@ -4672,6 +4699,70 @@ copy.
 Delete the linked package's nested `node_modules/react` after linking if your
 package manager duplicated it.
 
+#### When the duplicate can't be installed away: declare it single-copy
+
+A `link:` dependency on a **separate checkout** is the case none of the
+above reaches. The linked package's files live in the other repo, so Node and Bun resolve their
+imports from _that_ repo's real path - and that repo's install owns its
+`node_modules`. Peer deps don't help (the copy is already installed there),
+`overrides` don't help (they govern your install, not theirs), and deleting the
+nested copy is undone by the next install in the sibling repo. Only a resolver can answer this:
+the walk has to be intercepted, not rearranged.
+
+Declare the packages in your app's `package.json`. It is a **static**
+declaration on purpose - `nifra check` reads it without importing your config, so
+the preflight never executes app code:
+
+```ts
+{
+  "name": "my-app",
+  "dependencies": {
+    "react": "19.2.8",
+    "@example/ui": "link:../design-system/packages/ui"
+  },
+  "nifra": {
+    "singleCopy": ["react", "react-dom", "@nifrajs/*"]
+  }
+}
+```
+
+`"singleCopy": true` is shorthand for Nifra's built-in identity-sensitive set:
+`@nifrajs/*`, `react`, `react-dom`, `preact`,
+`solid-js`, `svelte`, `vue`. Entries may be exact names or a
+`@scope/*` pattern. `@nifrajs/*` belongs in this set for the same reason
+React does: two copies of `@nifrajs/core` are two distinct `Server`
+classes, so `.merge()` stops accepting an app built against the other one.
+
+**The build honours the declaration on its own** -
+`buildClient` and `buildServer` inject the resolver, so bundled output
+already loads one copy. Unbundled phases do not: Bun's _runtime_ resolver never offers a
+bare specifier to a plugin, so `bun test`, `bun run`, and preloaded
+scripts still load both copies unless you preload the registrar:
+
+```ts
+# bunfig.toml
+preload = ["@nifrajs/core/single-copy/register"]
+
+[test]
+preload = ["@nifrajs/core/single-copy/register"]
+```
+
+Both sections matter, and they are independent: `preload` covers
+`bun run`, `[test].preload` covers `bun test`. Declaring
+without preloading is a real state, not a mistake -
+`nifra check` reports it and names the phase left uncovered.
+
+**What it will not do:** redirect across _versions_. If the two copies are
+`19.2.7` and `19.2.8`, the redirect is skipped and
+`nifra check` still fails with `version-skew`. Silently collapsing a
+version difference would trade a loud install problem for a quiet behavioural one; align the
+ranges instead.
+
+A declared duplicate is **reported, not suppressed**.
+`nifra check` keeps printing the copies as a warning and
+`nifra doctor` lists them under "deduplicated by declaration", so the topology stays
+visible - it just stops being fatal.
+
 [!NOTE]
 
 This applies to every framework with module-global render state, not just React (Preact,
@@ -5339,9 +5430,9 @@ export const hydrate = false   // opt out of full-document hydration (static / i
 export default function User(props) { /* props.data, props.actionData, props.params */ }
 ```
 
-[!NOTE] An `action` may return a `Response` (a `redirect()`,
-say) - it's passed through untouched. Any other return is serialized as
-`actionData`.
+[!NOTE] An `action` may return a control-flow value - a `redirect()` or a
+`status(...)` render, or a hand-rolled `Response` - and it's passed
+through untouched. Any other return is serialized as `actionData`.
 
 ### Two ways to handle a request
 
@@ -6434,6 +6525,94 @@ If capabilities are configured, review a new snapshot and run
 Exercise authentication, redirects, backend mounting, SSE/WebSocket routes, and each deploy
 adapter the application uses.
 
+## Nifra 3.0 migration guide - upgrade from 2.x
+
+> Upgrade a Nifra 2.x application to 3.0: automated dependency pins, the plain-data redirect return value, the frozen reserved typed-client segment keys and their codemod, the Node proxy transport default, and the release gates.
+
+Nifra 3.0 makes a redirect the same plain-data value an ordinary return is, and freezes the
+reserved typed-client segment keys into a published contract. The upgrade command handles the
+deterministic dependency pins; this guide covers the two structural changes it deliberately
+cannot guess, plus the Node proxy transport default.
+
+### 1. Run the executable upgrade
+
+```ts
+
+```
+
+The command pins every matching `@nifrajs/*`, `Nifra`, and
+`create-nifra` dependency to `3.0.0` while preserving
+caret/tilde/exact style. No package is removed and no import specifier moves this release, so
+the runner only pins. Dry-run is the default; `--write` applies and verifies with
+`nifra check`.
+
+### 2. Read redirects as plain data
+
+`redirect(...)` now returns the same plain render value `status(...)`
+produces, not a Web `Response`. Same bytes on the wire, now with a
+`content-length` on Node instead of a chunked empty body. It is still returned or
+thrown from the same places - loader, action, layout gate - and `return redirect()`
+/ `throw redirect()` stay interchangeable, including the client-submit conversion to
+a 204 with `X-Nifra-Redirect`.
+
+**Breaking:** the value is no longer a `Response`, so
+`.status`, `.headers`, and `instanceof Response` are gone from
+it. Read `.plain`, build one with `toResponse()` when needed, pass headers
+through the second argument, and assert on `.plain` in tests. A hand-rolled
+`Response` from a loader or action is untouched - only what `redirect()`
+itself returns changed.
+
+```ts
+
+```
+
+### 3. Fix reserved typed-client segments
+
+The reserved proxy keys are now a frozen, published contract. A route whose static path
+segment spells one of them - an HTTP verb in any casing, or `subscribe`,
+`ws`, `index`, `then` - is unreachable by property access,
+because the proxy resolves the reserved key before a path segment. The types now reject that
+access at compile time instead of silently reaching the wrong node.
+
+```ts
+
+```
+
+Run `nifra fix --code NF-C018` to rewrite the affected call sites. It reads them
+from the compiler rather than a text search, so it finds every one and never mistakes a real
+`.delete` verb call for a path segment; a site it cannot rewrite confidently
+(bracket access, a node held in a variable) is reported and left alone.
+`nifra routes` annotates a colliding route with the spelling that reaches it, in
+both the table and `--json`. The set is exported as the one place it is written down.
+
+```ts
+
+```
+
+### 4. Review the Node proxy transport (only if you use it)
+
+On Node, `@nifrajs/proxy` now defaults to the undici transport, shipped from the new
+`@nifrajs/proxy/undici` subpath. Pass an explicit `transport` to
+`createProxy` to override it.
+
+```ts
+
+```
+
+### 5. Run the release gates
+
+-
+Run `nifra check --json` and fix every error, including any remaining NF-C018.
+
+-
+If the project has `nifra.assurance.ts`, run `nifra assure --json`.
+
+- Run the application test suite and a production build.
+
+-
+Exercise every redirect path - loader, action, and layout gate - and, if the app proxies,
+each deploy adapter it uses.
+
 ## Nifra - Migrating from Express, Hono, Fastify & Elysia
 
 > Move a backend to Nifra: routing, middleware, validation, and body parsing map directly from Express, Hono, Fastify, and Elysia - and you gain a typed client, multi-runtime deploy, and optional SSR.
@@ -7691,8 +7870,8 @@ app.get("/me", async (c) => {
 
 ## Protect a route
 
-`requireSession(auth, request, options?)` returns the non-null session or **throws a `Response`** -
-nifra returns a thrown `Response` as-is, short-circuiting the handler:
+`requireSession(auth, request, options?)` returns the non-null session or **throws a Nifra `ResponseResult`** -
+nifra handles the thrown `ResponseResult` as control flow, short-circuiting the handler:
 
 ```ts
 import { requireSession } from "@nifrajs/better-auth"
@@ -7716,7 +7895,7 @@ export const loader = async ({ request }) => {
 | --- | --- |
 | `betterAuth(auth, options?)` | Plugin that mounts better-auth's handler at `${basePath}/*` for GET + POST. |
 | `getSession(auth, request)` | `Promise<SessionOf<A> \| null>` - typed wrapper over `auth.api.getSession`. |
-| `requireSession(auth, request, options?)` | Returns the session or throws a `Response` (302 `redirectTo` / 401). |
+| `requireSession(auth, request, options?)` | Returns the session or throws a Nifra `ResponseResult` (302 `redirectTo` / 401). |
 | `SessionOf<A>` | The non-null session payload type inferred from your `auth`. |
 | `BetterAuthLike` | The structural contract a better-auth instance satisfies. |
 
@@ -8013,6 +8192,31 @@ bun add @nifrajs/content
 - Reference: <https://nifra.dev/docs>
 - AI-readable: <https://nifra.dev/llms.txt>
 
+## Typed indexes and joins
+
+Build an equality lookup and deterministic query index from a baked collection. `where` is field
+equality, `range` supports typed string/number comparisons, sorting is stable (slug is the tie-breaker),
+and pages use an opaque cursor rather than an offset:
+
+```ts
+const posts = indexCollection(await bakeCollection(blog), {
+  by: "section",
+  sort: { field: "publishedAt", dir: "desc" },
+})
+
+const page = posts.query({ where: { section: "news" }, limit: 20 })
+const next = page.nextCursor === undefined
+  ? undefined
+  : posts.query({ where: { section: "news" }, cursor: page.nextCursor, limit: 20 })
+```
+
+`posts.baked` is JSON-safe and can be serialized into an edge bundle; `fromBakedIndex` rehydrates it
+without filesystem access. `joinCollections(left, right, "id")` gives one-to-many rows by default.
+Pass `{ cardinality: "one-to-one" }` to require unique right-side keys; duplicate right keys fail the
+build loudly. The join key must exist on both frontmatter types with the same TypeScript value type.
+These APIs index only validated local/baked content; credentialed CMS ingestion and tenant data remain
+outside this public package.
+
 MIT
 
 ## For AI agents
@@ -8069,6 +8273,10 @@ import { defineChannel, memoryChannelHub } from "@nifrajs/core/channel"
 - **Lifecycle middleware.** `derive`/`decorate` extend the typed context;
   `onRequest`/`beforeHandle`/`afterHandle`/`onResponse`/`onError` run around handlers;
   `use(middleware)` applies a bundle.
+- **Portable response observation.** The header/body/raw observer methods are opt-in so ordinary
+  servers stay lean: add `responseObserver()` from `@nifrajs/core/response-observer` before calling
+  `onResponseHeaders`, `onResponseBody`, or `onResponseRaw`. Official middleware that uses these
+  tiers installs the compatibility runtime automatically.
 - **Hardening built in.** `stop({ drainMs })` graceful shutdown (+ opt-in SIGTERM/
   SIGINT), `requestTimeoutMs` (+ `ctx.signal` and `ctx.budget`), a streaming body-size cap, and a
   redacting structured `Logger`.
@@ -8283,6 +8491,98 @@ one cheap read instead of the whole corpus. For the wider framework: the repo's
 [`llms-full.txt`](../../llms-full.txt) is the full machine-readable corpus. Run `nifra check` as the
 done-gate, or `nifra mcp` to give the agent live project tools.
 
+## @nifrajs/edge
+
+Compact fetch-handler server for edge and serverless runtimes - Cloudflare Workers, Vercel Edge, Deno Deploy, Bun. Keeps the `server().get().post()` DX and the full request trust boundary (bounded body read, Content-Length pre-reject, prototype-pollution guard, JSON / urlencoded framing) in a fraction of the bundle. Zero runtime dependencies beyond `@nifrajs/core`.
+
+Part of the **[nifra](https://nifra.dev)** full-stack TypeScript framework - one core, five UI libraries, every runtime. Scaffold a new app with `bun create nifra`.
+
+## Why
+
+`@nifrajs/core`'s `server()` carries lifecycle hooks, cookies, response contracts, deadlines, WebSockets, and a plugin system. On an edge worker you often want none of that - just typed routing and a safe body. `@nifrajs/edge` is that subset: the same routing DX, the *same* body trust boundary (imported from core, never re-derived, so there is no second copy of the security contract to drift), and nothing else.
+
+The rejection envelopes are byte-for-byte the full Server's - so an app can start on `@nifrajs/edge` and graduate to `@nifrajs/core`'s `server()` without its clients noticing.
+
+## Install
+
+```sh
+bun add @nifrajs/edge @nifrajs/core
+```
+
+## Use
+
+```ts
+// worker.ts
+import { server, type StandardSchemaV1 } from "@nifrajs/edge"
+
+const createUser: StandardSchemaV1<{ name: string; age: number }> = /* zod, valibot, arktype, ... */
+
+const app = server()
+  .get("/users/:id", (c) => ({ id: c.params.id }))
+  .post("/users", { body: createUser }, (c) => ({ created: c.body.name, age: c.body.age }))
+
+export default app // { fetch } - a module worker handler
+```
+
+`c.params` is typed from the route pattern. `c.body` is narrowed to the schema's output. Return a value (rendered as JSON) or a `Response` for full control. Throw a `Response` for an early exit; any other throw becomes a flat `500`.
+
+## Context
+
+| Member | What |
+| --- | --- |
+| `c.request` | the raw `Request` |
+| `c.params` | path params, typed from the pattern (`/users/:id` -> `{ id: string }`) |
+| `c.body` | parsed, schema-validated body (`undefined` on a body-less route) |
+| `c.query()` | query string parsed to an object, on demand |
+| `c.header(name)` | a request header (case-insensitive), or `null` |
+
+## Options
+
+```ts
+server({ maxBodyBytes: 256_000, protoPoisoning: "strip" })
+```
+
+| Option | Default | What |
+| --- | --- | --- |
+| `maxBodyBytes` | `1_000_000` | body-size cap before a `413`, matching core |
+| `protoPoisoning` | `"reject"` | `__proto__` policy for JSON bodies: `"reject"` \| `"strip"` \| `"ignore"`, matching core |
+
+## Security
+
+The body trust boundary is on by default and imported from `@nifrajs/core` - the same lane the full Server runs, so there is one implementation, never a trimmed copy that could drift. On every body-bearing route it enforces:
+
+| Guard | Effect |
+| --- | --- |
+| Streaming byte cap | a length-less (chunked) body is drained under `maxBodyBytes`; once over, the stream is **cancelled** and rejected `413` - it is never buffered whole |
+| Content-Length pre-reject | a declared length over `maxBodyBytes` is `413` before a byte is read; a malformed length is `400` |
+| Prototype-pollution guard | an own `__proto__` key (or a poisoning-shaped `constructor.prototype`) in a JSON body is rejected (`"reject"`, default) or removed (`"strip"`) before it reaches your handler |
+| Media-type framing | JSON and urlencoded bodies are framed and capped; other content types get `415` |
+
+Rejection envelopes are byte-for-byte the full Server's.
+
+**Whether you need this depends on the runtime:**
+
+- **Stream runtimes** (Cloudflare Workers, Deno Deploy, Bun): the runtime hands your worker a live request stream with no size ceiling below its own memory limit. A single length-less request into an unguarded `.json()` buffers unbounded and can cross the isolate memory limit (~128 MB on Workers) - one request, one killed worker (and on auto-scaling platforms, a metered bill). Here the byte cap is **load-bearing**, not optional.
+- **Pre-capped serverless** (Vercel Edge ~4.5 MB, AWS API Gateway 6-10 MB, GCP 10-32 MB, Azure ~30 MB default): the platform already bounds the body at its edge, so the crash case is largely its job. The cap still earns its place by tightening that platform ceiling to your app's real intent and returning a consistent `413`. (Platform limits are documented ceilings - check current docs for your plan.)
+
+The prototype-pollution guard is **platform-independent**: no runtime guards `JSON.parse` for you, and a `__proto__`-bearing object becomes pollution the moment downstream code merges it. The guard stops it at ingress. Both defenses tune via [Options](#options).
+
+## Not included
+
+By design: no lifecycle / `around` hooks, cookies, response contracts, deadlines, WebSockets, or plugins. Reach for `@nifrajs/core`'s `server()` when an app needs those.
+
+## License
+
+MIT
+
+## For AI agents
+
+Start with [`LLM.md`](./LLM.md) - this package's contract card (the exports you call + its footguns),
+one cheap read instead of the whole corpus. For the wider framework: the repo's
+[`AGENTS.md`](../../AGENTS.md) is the copy-paste quick reference, and
+[`llms-full.txt`](../../llms-full.txt) is the full machine-readable corpus. Run `nifra check` as the
+done-gate, or `nifra mcp` to give the agent live project tools.
+
 ## @nifrajs/env
 
 Typed, validated environment variables. Define a schema once at startup; get a **frozen, typed**
@@ -8463,6 +8763,32 @@ one cheap read instead of the whole corpus. For the wider framework: the repo's
 [`llms-full.txt`](../../llms-full.txt) is the full machine-readable corpus. Run `nifra check` as the
 done-gate, or `nifra mcp` to give the agent live project tools.
 
+## @nifrajs/island-trigger
+
+Framework-neutral, browser-side trigger scheduling shared by Nifra’s two island runtimes:
+`@nifrajs/web/islands` and `@nifrajs/islets`.
+
+It has no DOM or UI-framework dependency. The public contract is the small `scheduleTrigger`
+primitive with these strategies:
+
+```ts
+import { scheduleTrigger } from "@nifrajs/island-trigger"
+
+const dispose = scheduleTrigger({ media: "(min-width: 768px)" }, () => {
+  // Activate the island.
+})
+
+dispose() // cancel before the trigger fires
+```
+
+`load`, `idle`, `visible`, and media-query triggers are one-shot. Idle and visibility strategies
+fall back safely when the browser capability is unavailable; malformed or oversized media queries
+remain inert. The package only schedules the callback - each island runtime owns its own markers,
+registry, signals, and framework integration.
+
+For AI agents, see [`LLM.md`](./LLM.md). The wider reference is in
+[`llms-full.txt`](../../llms-full.txt).
+
 ## @nifrajs/islets
 
 Fine-grained signals + declarative DOM bindings for islands - **interactivity in ~1.4 KB gz**, no
@@ -8779,7 +9105,9 @@ Bun GET, byte-identical on the wire). They are defaults - anything the request p
 `securityHeaders` and the default `poweredBy` ship this way.
 
 A middleware whose response hook only reads/writes **headers** but needs the request should use the
-portable `onResponseHeaders` hook - one implementation, fast on every runtime: it mutates the
+portable `onResponseHeaders` hook - enable the observer surface with
+`app.use(responseObserver())` from `@nifrajs/core/response-observer` before registering a custom
+hook. It remains one implementation, fast on every runtime: it mutates the
 response's own `Headers` on Bun/Deno and the outcome record on Node's direct socket writer, never
 materializing Web `Request`/`Response` objects. `cors` (origin reflection), static `cacheControl`,
 `language`, and `poweredBy({ respectExisting: false })` are built on it. Stateful middleware (`rateLimit` with the built-in key derivation,
@@ -8898,7 +9226,13 @@ authority. If neither option is set, treat the host in `request.url` as client-c
 
 The optional `static` root is served before `app.fetch` for GET and HEAD requests. It is a
 public asset directory and must contain nothing private: no secrets, source maps, build
-metadata, or user uploads.
+metadata, or user uploads. The directory and its ancestor path must be read-only and owned by
+the service (or otherwise protected from untrusted local writers). Nifra resolves and confines
+the file before opening it and refuses symlinked final files, but Node does not expose a native
+per-component `openat` primitive; a process that can mutate the tree concurrently can still
+create a local TOCTOU race. Mutable or attacker-writable static trees are therefore outside the
+adapter's guarantee. Store user-controlled files outside the static root and serve them through
+an application or object-storage path with its own validation policy.
 
 ## Graceful shutdown on signals
 
@@ -9929,11 +10263,11 @@ done-gate, or `nifra mcp` to give the agent live project tools.
 
 ## @nifrajs/client
 
-`ActionArgs`, `ActionData`, `ApiError`, `ApiProxy`, `client`, `ClientOptions`, `ClientRetryOptions`, `FetchFn`, `inProcessClient`, `InProcessClient`, `InProcessClientOptions`, `Jsonify`, `LoaderArgs`, `LoaderData`, `RegistryOf`, `ResponseContractViolation`, `Result`, `SubscribeOptions`, `Subscription`, `testClient`, `Treaty`, `TreatyFromRegistry`, `WsCallOptions`, `WsHandle`
+`ActionArgs`, `ActionData`, `ApiError`, `ApiProxy`, `client`, `ClientOptions`, `ClientRetryOptions`, `FetchFn`, `inProcessClient`, `InProcessClient`, `InProcessClientOptions`, `Jsonify`, `LoaderArgs`, `LoaderData`, `RegistryOf`, `RESERVED_EXACT_KEYS`, `RESERVED_KEY_READOUT`, `RESERVED_VERB_KEYS`, `reservedKeyFor`, `ResponseContractViolation`, `Result`, `SubscribeOptions`, `Subscription`, `testClient`, `Treaty`, `TreatyFromRegistry`, `WsCallOptions`, `WsHandle`
 
 ## @nifrajs/content
 
-`bakeCollection`, `BakedCollection`, `Entry`, `fromBaked`, `InferSchema`, `parseEntry`, `ParseEntryOptions`, `parseFrontmatter`, `StandardSchemaV1`, `StaticCollection`
+`bakeCollection`, `BakedCollection`, `BakedCollectionIndex`, `BakedCollectionJoin`, `BakedIndexBucket`, `ContentFieldKey`, `Entry`, `fromBaked`, `fromBakedIndex`, `fromBakedJoin`, `indexCollection`, `IndexedCollection`, `IndexedJoin`, `IndexOptions`, `IndexPage`, `IndexQueryOptions`, `IndexRange`, `IndexRanges`, `IndexSort`, `IndexWhere`, `InferSchema`, `JoinCardinality`, `joinCollections`, `JoinedRow`, `parseEntry`, `ParseEntryOptions`, `parseFrontmatter`, `SharedKey`, `StandardSchemaV1`, `StaticCollection`
 
 ## @nifrajs/core
 
@@ -9951,6 +10285,10 @@ done-gate, or `nifra mcp` to give the agent live project tools.
 
 `devtools`, `DevToolsClientOptions`, `devtoolsClientScript`, `DevToolsEvent`, `DevToolsOptions`, `DevToolsQuery`, `filterDevToolsEvents`
 
+## @nifrajs/edge
+
+`EdgeContext`, `EdgeHandler`, `EdgeOptions`, `EdgeServer`, `Method`, `Params`, `QueryValue`, `server`, `StandardSchemaV1`, `toFetchHandler`
+
 ## @nifrajs/env
 
 `boolean`, `defineEnv`, `DefineEnvOptions`, `enumValue`, `env`, `EnvResult`, `EnvShape`, `InferOutput`, `number`, `port`, `StandardResult`, `StandardSchemaV1`, `string`, `url`
@@ -9967,9 +10305,13 @@ done-gate, or `nifra mcp` to give the agent live project tools.
 
 `cloudflareLoader`, `CloudflareLoaderOptions`, `createPngRasterizer`, `createResvgRasterizer`, `HtmlImageAttrs`, `identityLoader`, `imageDimensions`, `ImageFormat`, `ImageInfo`, `ImageLoader`, `ImageProps`, `OgImageOptions`, `OgImageRasterized`, `OgImageRasterizer`, `ogImageResponse`, `PngRenderer`, `readImageDimensions`, `renderOgImage`, `ResolvedImage`, `resolveImage`, `ResvgConstructor`, `ResvgRenderer`, `selfHostedLoader`, `SelfHostedLoaderOptions`, `signImageUrl`, `SignImageUrlOptions`, `toHtmlAttrs`
 
+## @nifrajs/island-trigger
+
+`IslandStrategy`, `MAX_MEDIA_QUERY_LENGTH`, `scheduleTrigger`, `TriggerOptions`
+
 ## @nifrajs/islets
 
-`batch`, `BindableElement`, `BindableRoot`, `bindScope`, `computed`, `effect`, `island`, `IslandContext`, `IslandHost`, `IslandScope`, `IslandSetup`, `islandState`, `mountIslands`, `signal`, `Signal`
+`batch`, `BindableElement`, `BindableRoot`, `bindScope`, `computed`, `effect`, `island`, `IslandContext`, `IslandHost`, `IslandScope`, `IslandSetup`, `islandState`, `IslandStrategy`, `MountIslandOptions`, `mountIslands`, `signal`, `Signal`
 
 ## @nifrajs/jobs
 
@@ -10005,7 +10347,7 @@ done-gate, or `nifra mcp` to give the agent live project tools.
 
 ## @nifrajs/proxy
 
-`createProxy`, `ProxyContext`, `ProxyHandler`, `ProxyOptions`
+`createProxy`, `fetchTransport`, `FetchTransportOptions`, `NativeProxyTransport`, `NativeProxyTransportRequest`, `NativeProxyUpstreamResponse`, `NodeNativeProxyRequest`, `NodeNativeProxyResponse`, `ProxyContext`, `ProxyHandler`, `ProxyOptions`, `ProxyTransport`, `ProxyUpstreamRequest`, `ProxyUpstreamResponse`
 
 ## @nifrajs/runner
 
@@ -10033,7 +10375,7 @@ done-gate, or `nifra mcp` to give the agent live project tools.
 
 ## @nifrajs/web
 
-`Action`, `ACTION_GLOBAL`, `apiKey`, `assertRenderAdapterConformance`, `Blocker`, `BlockerController`, `BlockerFunction`, `BlockerLocation`, `BlockerState`, `BrowserNavigate`, `buildManifest`, `CachedResponse`, `CacheStore`, `canonical`, `clientEntry`, `ClientRouter`, `ClientRouterOptions`, `createClientRouter`, `createMatcher`, `createMutation`, `createQueryClient`, `createWebApp`, `CreateWebAppOptions`, `DATA_GLOBAL`, `DATA_HEADER`, `DEFAULT_DEV_PORT`, `defer`, `Deferred`, `DehydratedState`, `disableDraft`, `DRAFT_COOKIE`, `DraftCookieControls`, `enableDraft`, `EnableDraftOptions`, `enumerateStaticRoutes`, `Fetcher`, `FetcherState`, `FetchRouteData`, `filePathToPattern`, `filePathToPatterns`, `FontDisplay`, `fontFace`, `FontFace`, `fontPreload`, `FontPreloadInput`, `FontSource`, `gate`, `generateClientEntry`, `GenerateClientEntryOptions`, `generateRouteSearchTypes`, `GenerateRouteSearchTypesOptions`, `generateServerManifest`, `GenerateServerManifestOptions`, `getBrowserNavigate`, `GetStaticPaths`, `gone`, `hashQueryKey`, `IDLE_BLOCKER`, `InertScriptType`, `InfiniteData`, `InfiniteQueryHandle`, `InfiniteQueryOptions`, `isDraftEnabled`, `ISR_REVALIDATE_HEADER`, `ISR_REVALIDATE_TAGS_HEADER`, `ISR_STATUS_HEADER`, `ISRApp`, `ISROptions`, `ISRPlatform`, `jsonLd`, `KVCacheStore`, `KVCacheStoreOptions`, `KVNamespaceLike`, `LAYOUT_DATA_GLOBAL`, `LayoutEntry`, `LinkDescriptor`, `Loader`, `LoaderContext`, `manifest`, `Manifest`, `MemoryCacheStore`, `MemoryCacheStoreOptions`, `mergeHeads`, `meta`, `Meta`, `MetaArgs`, `MetaDescriptor`, `MetaInput`, `MountRouterOptions`, `MutationCallbacks`, `MutationHandle`, `MutationState`, `MutationStatus`, `NAV_FROM_HEADER`, `NavigateFunction`, `NavigateOptions`, `NavigateSearchOf`, `NavigateTargetInput`, `notFound`, `openGraph`, `OpenGraphInput`, `PRE_HYDRATION_GUARD`, `previewEndpoint`, `PreviewEndpointOptions`, `PublicDirCache`, `QueryClient`, `QueryClientOptions`, `QueryHandle`, `QueryOptions`, `QueryState`, `QueryStatus`, `redirect`, `REDIRECT_HEADER`, `RedirectOptions`, `registerBlocker`, `RenderAdapter`, `RenderAdapterConformanceError`, `RenderAdapterConformanceFixture`, `RenderAssemblyCache`, `RenderedPage`, `renderPage`, `RenderPageInput`, `RenderPageOptions`, `renderPageResult`, `RenderProps`, `resolveMeta`, `resolveNavigate`, `resolvePublicPath`, `RETAIN_HEADER`, `revalidate`, `REVALIDATE_HEADER`, `revalidateEndpoint`, `RevalidateEndpointOptions`, `RevalidateResult`, `ROOT_ATTRIBUTE`, `ROUTE_GLOBAL`, `RouteEntry`, `RouteMatch`, `RouteModule`, `RoutePattern`, `RouterState`, `RouteSearch`, `routeStyles`, `ScriptDescriptor`, `searchOf`, `SearchOf`, `searchOfChain`, `serializeData`, `serializeSearch`, `servePublicDir`, `ServePublicDirOptions`, `SERVER_FN_MODULE`, `SERVER_ONLY_MODULE`, `ServerOnly`, `setBlockerController`, `setBrowserNavigate`, `setSsrModuleLoader`, `ssrModuleLoader`, `SsrModuleLoader`, `StaticPath`, `StaticPaths`, `StaticRoutes`, `STATUS_HEADER`, `statusPage`, `StatusPageOptions`, `styles`, `Submission`, `SubmitOptions`, `unsafeInlineScript`, `UnsafeScriptDescriptor`, `withISR`
+`Action`, `ACTION_GLOBAL`, `apiKey`, `assertRenderAdapterConformance`, `assertStaticBoundaryImports`, `Blocker`, `BlockerController`, `BlockerFunction`, `BlockerLocation`, `BlockerState`, `Boundary`, `BOUNDARY_GLOBAL`, `BoundaryDescriptor`, `boundaryDescriptors`, `BoundaryError`, `BoundaryMode`, `boundaryModeKey`, `BoundaryRegistration`, `BoundaryRequestCtx`, `BoundaryState`, `BoundaryStates`, `BoundaryStatus`, `BrowserNavigate`, `buildManifest`, `CachedResponse`, `CacheStore`, `canonical`, `ClientAction`, `ClientActionArgs`, `ClientActionResult`, `clientEntry`, `ClientLoader`, `ClientLoaderArgs`, `ClientRequestBody`, `ClientRouteHooks`, `ClientRouter`, `ClientRouterOptions`, `createClientRouter`, `createMatcher`, `createMutation`, `createQueryClient`, `createWebApp`, `CreateWebAppOptions`, `DATA_GLOBAL`, `DATA_HEADER`, `DEFAULT_DEV_PORT`, `defer`, `Deferred`, `DehydratedState`, `disableDraft`, `DRAFT_COOKIE`, `DraftCookieControls`, `DynamicBoundary`, `DynamicBoundaryBatch`, `enableDraft`, `EnableDraftOptions`, `enumerateStaticRoutes`, `Fetcher`, `FetcherState`, `FetchRouteData`, `filePathToPattern`, `filePathToPatterns`, `FontDisplay`, `fontFace`, `FontFace`, `fontPreload`, `FontPreloadInput`, `FontSource`, `gate`, `generateClientEntry`, `GenerateClientEntryOptions`, `generateRouteSearchTypes`, `GenerateRouteSearchTypesOptions`, `generateServerManifest`, `GenerateServerManifestOptions`, `getBrowserNavigate`, `GetStaticPaths`, `gone`, `hashQueryKey`, `IDLE_BLOCKER`, `InertScriptType`, `InfiniteData`, `InfiniteQueryHandle`, `InfiniteQueryOptions`, `InterceptBoundary`, `isDraftEnabled`, `ISR_REVALIDATE_HEADER`, `ISR_REVALIDATE_TAGS_HEADER`, `ISR_STATUS_HEADER`, `ISRApp`, `ISROptions`, `ISRPlatform`, `jsonLd`, `KVCacheStore`, `KVCacheStoreOptions`, `KVNamespaceLike`, `LAYOUT_DATA_GLOBAL`, `LayoutEntry`, `LinkDescriptor`, `Loader`, `LoaderContext`, `manifest`, `Manifest`, `MemoryCacheStore`, `MemoryCacheStoreOptions`, `MemoryStaticBoundaryCache`, `mergeHeads`, `meta`, `Meta`, `MetaArgs`, `MetaDescriptor`, `MetaInput`, `MountRouterOptions`, `MutationCallbacks`, `MutationHandle`, `MutationState`, `MutationStatus`, `NAV_FROM_HEADER`, `NavigateFunction`, `NavigateOptions`, `NavigateSearchOf`, `NavigateTargetInput`, `notFound`, `openGraph`, `OpenGraphInput`, `PendingBoundary`, `PRE_HYDRATION_GUARD`, `previewEndpoint`, `PreviewEndpointOptions`, `PublicDirCache`, `QueryClient`, `QueryClientOptions`, `QueryHandle`, `QueryOptions`, `QueryState`, `QueryStatus`, `redirect`, `REDIRECT_HEADER`, `RedirectOptions`, `registerBlocker`, `RenderAdapter`, `RenderAdapterConformanceError`, `RenderAdapterConformanceFixture`, `RenderAssemblyCache`, `RenderedPage`, `renderPage`, `RenderPageInput`, `RenderPageOptions`, `renderPageResult`, `RenderProps`, `resolveDynamicBoundaries`, `resolveMeta`, `resolveNavigate`, `resolvePublicPath`, `resolveStaticBoundaries`, `RETAIN_HEADER`, `revalidate`, `REVALIDATE_HEADER`, `revalidateEndpoint`, `RevalidateEndpointOptions`, `RevalidateResult`, `ROOT_ATTRIBUTE`, `ROUTE_GLOBAL`, `RouteEntry`, `RouteMatch`, `RouteModule`, `RoutePattern`, `RouterState`, `RouteSearch`, `routeStyles`, `ScriptDescriptor`, `searchOf`, `SearchOf`, `searchOfChain`, `serializeData`, `serializeSearch`, `servePublicDir`, `ServePublicDirOptions`, `SERVER_FN_MODULE`, `SERVER_ONLY_MODULE`, `ServerOnly`, `setBlockerController`, `setBrowserNavigate`, `setSsrModuleLoader`, `ssrModuleLoader`, `SsrModuleLoader`, `startDynamicBoundaries`, `StaticBoundary`, `StaticBoundaryCache`, `StaticBoundaryImportEdge`, `StaticBoundaryRoot`, `StaticCtx`, `StaticPath`, `StaticPaths`, `StaticRoutes`, `STATUS_HEADER`, `statusPage`, `StatusPageOptions`, `styles`, `Submission`, `SubmitOptions`, `unsafeInlineScript`, `UnsafeScriptDescriptor`, `withISR`
 
 ## @nifrajs/web-preact