@fougere/next 0.2.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fougere contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/config.d.ts

@@ -0,0 +1,3 @@
+import type { NextConfig } from 'next';
+export declare function withFougere(config?: NextConfig): NextConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAavC,wBAAgB,WAAW,CAAC,MAAM,GAAE,UAAe,GAAG,UAAU,CAgC/D"}

package/dist/config.js

@@ -0,0 +1,75 @@
+/**
+ * `withFougere(config)` — what Next has to be told so a Fougere app builds.
+ *
+ * ```ts
+ * // next.config.ts
+ * import { withFougere } from '@fougere/next/config';
+ *
+ * export default withFougere({ reactStrictMode: true });
+ * ```
+ *
+ * The adapter owns the host's quirks. Nothing here leaks into the framework, and
+ * nothing here asks the developer to write anything twice — a Next-specific
+ * problem gets a Next-specific answer, in the Next package.
+ *
+ * Two things are set, both measured against a real production build:
+ *
+ * 1. **Class names survive minification.** Designation is class + verb, so
+ *    `invoke(Post, 'list')` and `useQuery(Post, 'list')` read `Post.name`. Next's
+ *    minifier renames it, and the call goes looking for an entity nobody hosts —
+ *    `Entity 'j' is not hosted here. Hosted here: post`. Next's own knob
+ *    (`noMangling`) is internal and all-or-nothing, so the minimizer is replaced by
+ *    terser with `keep_classnames`, which keeps mangling everything else.
+ *    Verified: the production browser chunk contains `class Post extends`.
+ *
+ * 2. **The scan's dependencies stay out of the bundle.** A boot reads frond
+ *    sources off disk through jiti, so those packages must be loaded at runtime
+ *    rather than compiled in.
+ *
+ * **Limit, stated rather than discovered later:** this rides Next's `webpack()`
+ * hook, which Turbopack ignores. Next 16 builds with Turbopack by default, so an
+ * app on 16 needs `next build --webpack` until Turbopack exposes a minifier option.
+ * Next also documents its webpack config as outside semver.
+ */
+import TerserPlugin from 'terser-webpack-plugin';
+/** Packages a Fougere boot loads at runtime — they must not be bundled. */
+const RUNTIME_PACKAGES = [
+    '@fougere/app',
+    '@fougere/core',
+    '@fougere/next',
+    '@fougere/schema-sql',
+    'better-sqlite3',
+    'jiti',
+    'typescript',
+];
+export function withFougere(config = {}) {
+    const userWebpack = config.webpack;
+    return {
+        ...config,
+        // Additive: whatever the app already listed is kept.
+        serverExternalPackages: [
+            ...new Set([...(config.serverExternalPackages ?? []), ...RUNTIME_PACKAGES]),
+        ],
+        webpack: (webpackConfig, context) => {
+            // The app's own webpack function runs FIRST, so it sees an untouched config
+            // and this never silently discards what it did.
+            const base = userWebpack ? userWebpack(webpackConfig, context) : webpackConfig;
+            base.optimization ??= {};
+            // ONLY the JS minifier is replaced. Next's minimizers are plain functions with
+            // no readable options, so they are told apart by their source: index 0 loads
+            // `minify-webpack-plugin` (JS), index 1 loads `css-minimizer-plugin`. Replacing
+            // the whole array — which this did at first — silently dropped CSS minification
+            // and anything the app's own webpack function had added.
+            const isJsMinifier = (m) => String(m).includes('minify-webpack-plugin');
+            base.optimization.minimizer = [
+                ...(base.optimization.minimizer ?? []).filter((m) => !isJsMinifier(m)),
+                // `keep_fnames` is deliberately absent: designation reads a CLASS name and
+                // nothing in this path reads a function name. Keeping every function name
+                // costs bundle size for an invariant nothing has demonstrated.
+                new TerserPlugin({ terserOptions: { keep_classnames: true } }),
+            ];
+            return base;
+        },
+    };
+}
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,YAAY,MAAM,uBAAuB,CAAC;AAGjD,2EAA2E;AAC3E,MAAM,gBAAgB,GAAG;IACvB,cAAc;IACd,eAAe;IACf,eAAe;IACf,qBAAqB;IACrB,gBAAgB;IAChB,MAAM;IACN,YAAY;CACb,CAAC;AAEF,MAAM,UAAU,WAAW,CAAC,MAAM,GAAe,EAAE;IACjD,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC;IAEnC,OAAO;QACL,GAAG,MAAM;QACT,qDAAqD;QACrD,sBAAsB,EAAE;YACtB,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,sBAAsB,IAAI,EAAE,CAAC,EAAE,GAAG,gBAAgB,CAAC,CAAC;SAC5E;QACD,OAAO,EAAE,CAAC,aAAa,EAAE,OAAO,EAAE,EAAE;YAClC,4EAA4E;YAC5E,gDAAgD;YAChD,MAAM,IAAI,GAAG,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC;YAE/E,IAAI,CAAC,YAAY,KAAK,EAAE,CAAC;YACzB,+EAA+E;YAC/E,6EAA6E;YAC7E,gFAAgF;YAChF,gFAAgF;YAChF,yDAAyD;YACzD,MAAM,YAAY,GAAG,CAAC,CAAU,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,uBAAuB,CAAC,CAAC;YACjF,IAAI,CAAC,YAAY,CAAC,SAAS,GAAG;gBAC5B,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAU,EAAE,EAAE,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;gBAC/E,2EAA2E;gBAC3E,0EAA0E;gBAC1E,+DAA+D;gBAC/D,IAAI,YAAY,CAAC,EAAE,aAAa,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,EAAE,CAAC;aAC/D,CAAC;YAEF,OAAO,IAAI,CAAC;QACd,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `@fougere/next` — what is Next about hosting a Fougere app, and nothing else.
+ *
+ * The package is deliberately thin, and its thinness is the measurement: the three
+ * doors are Web-standard handlers living in `@fougere/app/web`, the four primitives
+ * are React hooks living in `@fougere/react`, and neither imports Next. What is
+ * left here is mounting (Next has no module API, so routes are three one-line files
+ * under `app/`) and `next/headers`, the one import that is genuinely Next's.
+ *
+ * ```ts
+ * // app/%5Ffougere/call/[[...surface]]/route.ts   ← %5F, not _, see routes/call.ts
+ * export { POST } from '@fougere/next/call';
+ * // app/%5Ffougere/session/route.ts
+ * export { GET } from '@fougere/next/session';
+ * // app/api/[...fougere]/route.ts
+ * export { GET, POST, PUT, PATCH, DELETE } from '@fougere/next/rest';
+ * ```
+ *
+ * Nothing else in the app moves: pages, layouts, existing route handlers and an
+ * existing auth setup are untouched. The scan runs on the first request that needs
+ * the app (`useFougereApp` is lazy and memoized), so there is no build hook to
+ * install and no generated file to keep in sync.
+ *
+ * Client primitives: `@fougere/react`.
+ */
+export { invoke, getSession } from './invoke.js';
+export { configureFougere, useFougereApp, useFougereAuth, sessionViewOf, stateFor, type FougereServerConfig, type SessionView, } from '@fougere/app';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAUjD,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,aAAa,EACb,QAAQ,EACR,KAAK,mBAAmB,EACxB,KAAK,WAAW,GACjB,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,35 @@
+/**
+ * `@fougere/next` — what is Next about hosting a Fougere app, and nothing else.
+ *
+ * The package is deliberately thin, and its thinness is the measurement: the three
+ * doors are Web-standard handlers living in `@fougere/app/web`, the four primitives
+ * are React hooks living in `@fougere/react`, and neither imports Next. What is
+ * left here is mounting (Next has no module API, so routes are three one-line files
+ * under `app/`) and `next/headers`, the one import that is genuinely Next's.
+ *
+ * ```ts
+ * // app/%5Ffougere/call/[[...surface]]/route.ts   ← %5F, not _, see routes/call.ts
+ * export { POST } from '@fougere/next/call';
+ * // app/%5Ffougere/session/route.ts
+ * export { GET } from '@fougere/next/session';
+ * // app/api/[...fougere]/route.ts
+ * export { GET, POST, PUT, PATCH, DELETE } from '@fougere/next/rest';
+ * ```
+ *
+ * Nothing else in the app moves: pages, layouts, existing route handlers and an
+ * existing auth setup are untouched. The scan runs on the first request that needs
+ * the app (`useFougereApp` is lazy and memoized), so there is no build hook to
+ * install and no generated file to keep in sync.
+ *
+ * Client primitives: `@fougere/react`.
+ */
+export { invoke, getSession } from './invoke.js';
+// `withFougere` is deliberately NOT re-exported here. It is build-time config and
+// it pulls terser in; the root entry is imported by pages, so re-exporting it sent
+// a bundler into the browser bundle (measured: `esbuild/lib/main.d.ts` failed to
+// parse inside `app/page.tsx`). Build-time and runtime do not share a door:
+// `@fougere/next/config`.
+// The boot, so an app can override its data layer from `instrumentation.ts` the way
+// a Nuxt app does from a Nitro plugin.
+export { configureFougere, useFougereApp, useFougereAuth, sessionViewOf, stateFor, } from '@fougere/app';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEjD,kFAAkF;AAClF,mFAAmF;AACnF,iFAAiF;AACjF,4EAA4E;AAC5E,0BAA0B;AAE1B,oFAAoF;AACpF,uCAAuC;AACvC,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,aAAa,EACb,QAAQ,GAGT,MAAM,cAAc,CAAC"}

package/dist/invoke.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The server dual of the couple, in Next — for server components, server actions
+ * and route handlers.
+ *
+ * Same designation as the browser side (class + verb), same return, same errors.
+ * `invokeOn` places the call: a local façade executes in memory, a frond listed in
+ * `remotes:` goes over JSON-RPC, and the caller never learns which.
+ *
+ * `next/headers` is the ONLY Next-specific import in this package — measured, and
+ * it is what a host actually owns: how to find the current request. It answers
+ * inside a request scope and throws outside one, so a call from a script or a test
+ * is simply anonymous, the same fallback Nitro's `useEvent()` gets.
+ */
+import { type SessionView } from '@fougere/app';
+import type { FrondCall, InvocationContext } from '@fougere/core';
+type EntityClass = {
+    name: string;
+};
+type CallInput = Partial<InvocationContext>;
+export declare function invoke<T = unknown>(entity: EntityClass, op: string, input?: CallInput): Promise<T>;
+export declare function invoke<T = unknown>(call: FrondCall, input?: CallInput): Promise<T>;
+/** The session a layout may hand to `<FougereSession>` so the page arrives knowing its user. */
+export declare function getSession(): Promise<SessionView>;
+export {};
+//# sourceMappingURL=invoke.d.ts.map

package/dist/invoke.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoke.d.ts","sourceRoot":"","sources":["../src/invoke.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAoD,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAClG,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAElE,KAAK,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AACpC,KAAK,SAAS,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;AAE5C,wBAAsB,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAC1G,wBAAsB,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAU1F,gGAAgG;AAChG,wBAAsB,UAAU,IAAI,OAAO,CAAC,WAAW,CAAC,CAEvD"}

package/dist/invoke.js

@@ -0,0 +1,33 @@
+/**
+ * The server dual of the couple, in Next — for server components, server actions
+ * and route handlers.
+ *
+ * Same designation as the browser side (class + verb), same return, same errors.
+ * `invokeOn` places the call: a local façade executes in memory, a frond listed in
+ * `remotes:` goes over JSON-RPC, and the caller never learns which.
+ *
+ * `next/headers` is the ONLY Next-specific import in this package — measured, and
+ * it is what a host actually owns: how to find the current request. It answers
+ * inside a request scope and throws outside one, so a call from a script or a test
+ * is simply anonymous, the same fallback Nitro's `useEvent()` gets.
+ */
+import { invokeOn, useFougereApp, sessionViewOf, stateFor } from '@fougere/app';
+export async function invoke(target, opOrInput, input) {
+    const app = await useFougereApp();
+    return invokeOn(app, target, opOrInput, input, await requestState());
+}
+/** The session a layout may hand to `<FougereSession>` so the page arrives knowing its user. */
+export async function getSession() {
+    return sessionViewOf(await requestState());
+}
+async function requestState() {
+    try {
+        // Awaited on purpose: async in Next 15+, synchronous before — `await` accepts both.
+        const { headers } = await import('next/headers');
+        return await stateFor(await headers());
+    }
+    catch {
+        return {};
+    }
+}
+//# sourceMappingURL=invoke.js.map

package/dist/invoke.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoke.js","sourceRoot":"","sources":["../src/invoke.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,aAAa,EAAE,QAAQ,EAAoB,MAAM,cAAc,CAAC;AAQlG,MAAM,CAAC,KAAK,UAAU,MAAM,CAC1B,MAA+B,EAC/B,SAA8B,EAC9B,KAAiB;IAEjB,MAAM,GAAG,GAAG,MAAM,aAAa,EAAE,CAAC;IAClC,OAAO,QAAQ,CAAI,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,YAAY,EAAE,CAAC,CAAC;AAC1E,CAAC;AAED,gGAAgG;AAChG,MAAM,CAAC,KAAK,UAAU,UAAU;IAC9B,OAAO,aAAa,CAAC,MAAM,YAAY,EAAE,CAAC,CAAC;AAC7C,CAAC;AAED,KAAK,UAAU,YAAY;IACzB,IAAI,CAAC;QACH,oFAAoF;QACpF,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,MAAM,CAAC,cAAc,CAAC,CAAC;QACjD,OAAO,MAAM,QAAQ,CAAC,MAAM,OAAO,EAAE,CAAC,CAAC;IACzC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC"}

package/dist/routes/call.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ```ts
+ * // app/%5Ffougere/call/[[...surface]]/route.ts
+ * export { POST } from '@fougere/next/call';
+ * ```
+ *
+ * The folder is `%5Ffougere`, not `_fougere`: the App Router treats a leading
+ * underscore as a PRIVATE folder and excludes it from routing, and `%5F` is Next's
+ * own escape for a literal one. Measured the hard way — the door 404'd while every
+ * other route answered.
+ *
+ * The optional catch-all is what serves a named surface: `/_fougere/call/public`
+ * selects the `public` audience.
+ */
+export { fougereCall as POST } from '@fougere/app/web';
+//# sourceMappingURL=call.d.ts.map

package/dist/routes/call.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call.d.ts","sourceRoot":"","sources":["../../src/routes/call.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,WAAW,IAAI,IAAI,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/routes/call.js

@@ -0,0 +1,16 @@
+/**
+ * ```ts
+ * // app/%5Ffougere/call/[[...surface]]/route.ts
+ * export { POST } from '@fougere/next/call';
+ * ```
+ *
+ * The folder is `%5Ffougere`, not `_fougere`: the App Router treats a leading
+ * underscore as a PRIVATE folder and excludes it from routing, and `%5F` is Next's
+ * own escape for a literal one. Measured the hard way — the door 404'd while every
+ * other route answered.
+ *
+ * The optional catch-all is what serves a named surface: `/_fougere/call/public`
+ * selects the `public` audience.
+ */
+export { fougereCall as POST } from '@fougere/app/web';
+//# sourceMappingURL=call.js.map

package/dist/routes/call.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"call.js","sourceRoot":"","sources":["../../src/routes/call.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,WAAW,IAAI,IAAI,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/routes/rest.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ```ts
+ * // app/api/[...fougere]/route.ts
+ * export { GET, POST, PUT, PATCH, DELETE } from '@fougere/next/rest';
+ * ```
+ *
+ * Five names for one handler, because Next decides which verbs a route accepts by
+ * which names it exports. Which verb reaches which OPERATION is decided elsewhere,
+ * off the table `schema-rest` generates — this file does not narrow it.
+ *
+ * Next resolves a static segment (`app/api/health/route.ts`) before a catch-all, so
+ * mounting this takes nothing away from an app that already serves `/api/*`.
+ */
+import { fougereRest } from '@fougere/app/web';
+export declare const GET: typeof fougereRest;
+export declare const POST: typeof fougereRest;
+export declare const PUT: typeof fougereRest;
+export declare const PATCH: typeof fougereRest;
+export declare const DELETE: typeof fougereRest;
+//# sourceMappingURL=rest.d.ts.map

package/dist/routes/rest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest.d.ts","sourceRoot":"","sources":["../../src/routes/rest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,eAAO,MAAM,GAAG,oBAAc,CAAC;AAC/B,eAAO,MAAM,IAAI,oBAAc,CAAC;AAChC,eAAO,MAAM,GAAG,oBAAc,CAAC;AAC/B,eAAO,MAAM,KAAK,oBAAc,CAAC;AACjC,eAAO,MAAM,MAAM,oBAAc,CAAC"}

package/dist/routes/rest.js

@@ -0,0 +1,20 @@
+/**
+ * ```ts
+ * // app/api/[...fougere]/route.ts
+ * export { GET, POST, PUT, PATCH, DELETE } from '@fougere/next/rest';
+ * ```
+ *
+ * Five names for one handler, because Next decides which verbs a route accepts by
+ * which names it exports. Which verb reaches which OPERATION is decided elsewhere,
+ * off the table `schema-rest` generates — this file does not narrow it.
+ *
+ * Next resolves a static segment (`app/api/health/route.ts`) before a catch-all, so
+ * mounting this takes nothing away from an app that already serves `/api/*`.
+ */
+import { fougereRest } from '@fougere/app/web';
+export const GET = fougereRest;
+export const POST = fougereRest;
+export const PUT = fougereRest;
+export const PATCH = fougereRest;
+export const DELETE = fougereRest;
+//# sourceMappingURL=rest.js.map

package/dist/routes/rest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest.js","sourceRoot":"","sources":["../../src/routes/rest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,MAAM,CAAC,MAAM,GAAG,GAAG,WAAW,CAAC;AAC/B,MAAM,CAAC,MAAM,IAAI,GAAG,WAAW,CAAC;AAChC,MAAM,CAAC,MAAM,GAAG,GAAG,WAAW,CAAC;AAC/B,MAAM,CAAC,MAAM,KAAK,GAAG,WAAW,CAAC;AACjC,MAAM,CAAC,MAAM,MAAM,GAAG,WAAW,CAAC"}

package/dist/routes/session.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ```ts
+ * // app/%5Ffougere/session/route.ts
+ * export { GET } from '@fougere/next/session';
+ * ```
+ */
+export { fougereSession as GET } from '@fougere/app/web';
+//# sourceMappingURL=session.d.ts.map

package/dist/routes/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/routes/session.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,cAAc,IAAI,GAAG,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/routes/session.js

@@ -0,0 +1,8 @@
+/**
+ * ```ts
+ * // app/%5Ffougere/session/route.ts
+ * export { GET } from '@fougere/next/session';
+ * ```
+ */
+export { fougereSession as GET } from '@fougere/app/web';
+//# sourceMappingURL=session.js.map

package/dist/routes/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","sourceRoot":"","sources":["../../src/routes/session.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,cAAc,IAAI,GAAG,EAAE,MAAM,kBAAkB,CAAC"}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@fougere/next",
+  "version": "0.2.0-alpha.0",
+  "description": "The Next.js adapter: mounting, and the one import that is genuinely Next.",
+  "keywords": [
+    "fougere",
+    "next",
+    "nextjs",
+    "react",
+    "typescript",
+    "fullstack",
+    "rpc"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chok/fougere.git",
+    "directory": "packages/app/next"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./call": {
+      "types": "./dist/routes/call.d.ts",
+      "import": "./dist/routes/call.js"
+    },
+    "./rest": {
+      "types": "./dist/routes/rest.d.ts",
+      "import": "./dist/routes/rest.js"
+    },
+    "./session": {
+      "types": "./dist/routes/session.d.ts",
+      "import": "./dist/routes/session.js"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "terser-webpack-plugin": "^5.3.14",
+    "@fougere/app": "0.2.0-alpha.0",
+    "@fougere/core": "0.2.0-alpha.0"
+  },
+  "devDependencies": {
+    "next": "^15.5.7",
+    "vitest": "^4.1.0"
+  },
+  "peerDependencies": {
+    "next": "^15.0.0 || ^16.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit -p tsconfig.test.json"
+  }
+}