@zenmanage/nextjs 0.0.0-stage → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zenmanage
+
+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/README.md

@@ -1,3 +1,330 @@
-# Temporary Holding Version
+# Zenmanage Next.js SDK
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://badge.fury.io/js/@zenmanage%2Fnextjs.svg)](https://www.npmjs.com/package/@zenmanage/nextjs)
+[![Build Status](https://github.com/zenmanage/zenmanage-nextjs/actions/workflows/ci.yml/badge.svg)](https://github.com/zenmanage/zenmanage-nextjs/actions/workflows/ci.yml)
+[![Codacy Badge](https://app.codacy.com/project/badge/Grade/b810a0a8c29f4af2a4013e29192b861e)](https://app.codacy.com/gh/zenmanage/zenmanage-nextjs/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
+[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg)](https://www.typescriptlang.org/)
+
+Feature flags for Next.js. Evaluate flags in Server Components, route handlers, `getServerSideProps` and middleware, and hand the results to Client Components so the first paint is already right.
+
+It builds on two packages you install alongside it:
+
+- [`@zenmanage/sdk`](https://www.npmjs.com/package/@zenmanage/sdk) evaluates flags on the server and at the edge.
+- [`@zenmanage/react`](https://www.npmjs.com/package/@zenmanage/react) provides the provider and hooks for Client Components.
+
+## What you get
+
+- Server helpers for the App Router and the Pages Router.
+- A bootstrap payload that carries server-evaluated flags to the browser. The server render and the first client render match, so there is no hydration mismatch and no flash of the default.
+- Middleware helpers that build an evaluation context from the request. They run on the Edge runtime and on Node.js.
+- Rules cached in memory and shared across calls, so a page with ten flags makes one fetch, not ten.
+
+## Installation
+
+```bash
+npm install @zenmanage/nextjs @zenmanage/react @zenmanage/sdk
+```
+
+Requires Next.js 13.4 or newer (up to 16), React 18.2 or 19, `@zenmanage/react` 1.0 or newer and `@zenmanage/sdk` 3.5 or newer. Tested against Next.js 13.4, 14, 15 and 16, on both routers.
+
+## Keys
+
+Two keys, and they never swap places:
+
+- **Server key (`srv_...`)** for Server Components, route handlers, `getServerSideProps` and middleware. Keep it in a server-only environment variable such as `ZENMANAGE_ENVIRONMENT_TOKEN`.
+- **Client key (`cli_...`)** for `NextFlagsProvider` in the browser. It is safe to expose, for example as `NEXT_PUBLIC_ZENMANAGE_ENVIRONMENT_TOKEN`.
+
+Mobile keys (`mob_...`) are not valid here. `NextFlagsProvider` throws if you give it a server key, because anything you pass to a Client Component ends up in the page.
+
+## Quick start
+
+A Server Component that reads a flag:
+
+```tsx
+import { Context } from '@zenmanage/sdk';
+import { getServerFlag } from '@zenmanage/nextjs';
+
+export default async function DashboardPage() {
+  const flag = await getServerFlag({
+    environmentToken: process.env.ZENMANAGE_ENVIRONMENT_TOKEN!,
+    key: 'dashboard-v2',
+    defaultValue: false,
+    context: Context.single('user', 'user-123', 'Jane'),
+  });
+
+  return <main>{flag.asBool() ? <NewDashboard /> : <LegacyDashboard />}</main>;
+}
+```
+
+If Zenmanage can't be reached, you get `defaultValue`, not an error.
+
+## Entry points
+
+| Import                         | Runs in           | Contains                                            |
+| ------------------------------ | ----------------- | --------------------------------------------------- |
+| `@zenmanage/nextjs`            | Server, Edge      | Everything below except the client entry point      |
+| `@zenmanage/nextjs/server`     | Server, Edge      | Server helpers                                      |
+| `@zenmanage/nextjs/middleware` | Edge, Node.js     | `buildContextFromRequest`, `evaluateMiddlewareFlag` |
+| `@zenmanage/nextjs/client`     | Client Components | `NextFlagsProvider`, `useFlag`, `useVariant`        |
+
+`@zenmanage/nextjs/client` starts with `'use client'`, so you can import it from a Server Component file without adding the directive yourself.
+
+## Server helpers
+
+All of them take your server key as `environmentToken`, plus the optional `apiEndpoint`, `cacheTtl`, `enableUsageReporting` and `logger`.
+
+| Function                        | Returns            | Use it to                                                                                |
+| ------------------------------- | ------------------ | ---------------------------------------------------------------------------------------- |
+| `getServerFlag(input)`          | `Flag`             | Read one flag. Pass `key`, `defaultValue`, `context`, `defaults`.                        |
+| `getFlagValue(input, fallback)` | the flag's value   | Read one flag as a `boolean`, `number`, `string` or JSON value, typed after `fallback`.  |
+| `getServerFlags(input)`         | `Flag[]`           | Read every flag.                                                                         |
+| `getBootstrapPayload(input)`    | `BootstrapPayload` | Evaluate flags for a client provider. See [Bootstrap](#bootstrapping-client-components). |
+| `createServerManager(input)`    | `FlagManager`      | Evaluate several flags against one context.                                              |
+| `preloadServerFlags(input)`     | `FlagManager`      | Load the rules up front and keep working with the manager.                               |
+| `createServerClient(options)`   | `Zenmanage`        | Get the shared SDK client. See the note below.                                           |
+| `clearServerClients()`          | `void`             | Drop every shared client and its cache. Useful in tests.                                 |
+
+`getFlagValue` returns `fallback` for a flag that doesn't exist, or when the API can't be reached. A `defaultValue` in the input, or an entry for the key in `defaults`, wins over it.
+
+### Caching
+
+Clients are shared per configuration (token, endpoint, TTL, usage setting and logger) for the life of the server process or Edge isolate. Rules are cached for 60 seconds unless you set `cacheTtl`. After that the next call fetches them again, so a flag change reaches your server within a minute.
+
+Prefer the helpers above to calling `createServerClient(...).flags()` yourself. A `FlagManager` loads its rules once and keeps them, whatever the TTL. The helpers hand you a fresh manager on every call, so the TTL applies.
+
+### Context
+
+Pass a `Context` from `@zenmanage/sdk` to target by user or attribute:
+
+```ts
+import { Attribute, Context } from '@zenmanage/sdk';
+
+const context = new Context('user', 'Jane Doe', 'user-123', [
+  new Attribute('country', ['US']),
+  new Attribute('plan', ['pro']),
+]);
+```
+
+A percentage rollout buckets by the context's identifier, so use a stable one.
+
+## Bootstrapping Client Components
+
+Client Components render on the server too, and they can't read the server key. So the server evaluates the flags, and the provider shows those values until the browser has its own.
+
+The pieces:
+
+1. `getBootstrapPayload` evaluates flags on the server and returns plain JSON.
+2. You pass that payload to `NextFlagsProvider` as a prop.
+3. `useFlag` from `@zenmanage/nextjs/client` returns the server's value on the server render and on the first client render. Because both see the same value, React hydrates cleanly.
+4. The browser loads its own rules. When they arrive, the live value replaces the server's. If they never arrive (a blocked CDN, no network), the server's value stays. The page doesn't switch to the code default.
+
+### App Router
+
+Evaluate in a Server Component and pass the payload down:
+
+```tsx
+// app/layout.tsx
+import { Context } from '@zenmanage/sdk';
+import { getBootstrapPayload } from '@zenmanage/nextjs';
+import { Providers } from './providers';
+
+export default async function RootLayout({ children }: { children: React.ReactNode }) {
+  const bootstrapPayload = await getBootstrapPayload({
+    environmentToken: process.env.ZENMANAGE_ENVIRONMENT_TOKEN!,
+    context: Context.single('user', 'user-123'),
+    keys: ['new-checkout'],
+    includeContext: true,
+  });
+
+  return (
+    <html lang="en">
+      <body>
+        <Providers bootstrapPayload={bootstrapPayload}>{children}</Providers>
+      </body>
+    </html>
+  );
+}
+```
+
+```tsx
+// app/providers.tsx
+'use client';
+
+import type { BootstrapPayload } from '@zenmanage/nextjs';
+import { NextFlagsProvider } from '@zenmanage/nextjs/client';
+
+export function Providers({
+  bootstrapPayload,
+  children,
+}: {
+  bootstrapPayload: BootstrapPayload;
+  children: React.ReactNode;
+}) {
+  return (
+    <NextFlagsProvider
+      environmentToken={process.env.NEXT_PUBLIC_ZENMANAGE_ENVIRONMENT_TOKEN!}
+      bootstrapPayload={bootstrapPayload}
+    >
+      {children}
+    </NextFlagsProvider>
+  );
+}
+```
+
+```tsx
+// app/checkout-button.tsx
+'use client';
+
+import { useFlag } from '@zenmanage/nextjs/client';
+
+export function CheckoutButton() {
+  const { value: enabled } = useFlag('new-checkout', false);
+
+  return <button>{enabled ? 'Checkout (new)' : 'Checkout'}</button>;
+}
+```
+
+### Pages Router
+
+Evaluate in `getServerSideProps` and pass the payload through props. It is plain JSON, so Next.js serializes it as is:
+
+```tsx
+// pages/checkout.tsx
+import type { GetServerSideProps } from 'next';
+import { Context } from '@zenmanage/sdk';
+import { getBootstrapPayload, type BootstrapPayload } from '@zenmanage/nextjs';
+import { NextFlagsProvider, useFlag } from '@zenmanage/nextjs/client';
+
+export const getServerSideProps: GetServerSideProps<{
+  bootstrapPayload: BootstrapPayload;
+}> = async () => ({
+  props: {
+    bootstrapPayload: await getBootstrapPayload({
+      environmentToken: process.env.ZENMANAGE_ENVIRONMENT_TOKEN!,
+      context: Context.single('user', 'user-123'),
+      keys: ['new-checkout'],
+      includeContext: true,
+    }),
+  },
+});
+
+function Checkout() {
+  const { value: enabled } = useFlag('new-checkout', false);
+  return <button>{enabled ? 'Checkout (new)' : 'Checkout'}</button>;
+}
+
+export default function CheckoutPage({ bootstrapPayload }: { bootstrapPayload: BootstrapPayload }) {
+  return (
+    <NextFlagsProvider
+      environmentToken={process.env.NEXT_PUBLIC_ZENMANAGE_ENVIRONMENT_TOKEN!}
+      bootstrapPayload={bootstrapPayload}
+    >
+      <Checkout />
+    </NextFlagsProvider>
+  );
+}
+```
+
+### What goes to the browser
+
+The payload is written into the page, so anyone can read it.
+
+- **`keys`** limits it to the flags your Client Components read. Leave it out and every flag in the environment is sent, names and values included.
+- **`includeContext: true`** adds the context to the payload, so the browser evaluates for the same user the server did. Leave it out if the context holds anything you don't want in the page source. Without it, the browser evaluates with no context unless you pass `context` to the provider.
+
+### `NextFlagsProvider`
+
+Takes everything `FlagsProvider` from `@zenmanage/react` takes (`environmentToken`, `apiEndpoint`, `cacheTtl`, `enableUsageReporting`, `context`, `defaults`, `preload`, `onError`, `client`), plus:
+
+| Prop                 | Use                                                                                             |
+| -------------------- | ----------------------------------------------------------------------------------------------- |
+| `bootstrapPayload`   | The payload from `getBootstrapPayload`. Pass it as a prop.                                      |
+| `bootstrapElementId` | Read the payload from a `<script id="...">` tag instead. Defaults to `__ZENMANAGE_BOOTSTRAP__`. |
+
+The browser reports itself to the API as `zenmanage-nextjs/<version>`.
+
+`useFlag` and `useVariant` from `@zenmanage/nextjs/client` take the same arguments as the ones in `@zenmanage/react`. With a bootstrap value for the key they return it, with `isLoading: false`, until the live value arrives. Without one they behave the same as the React hooks.
+
+`FlagGate` and `withFlag` come from `@zenmanage/react` and work inside `NextFlagsProvider`, but they don't use the bootstrap. They wait for the browser's own value.
+
+### Script tag
+
+If you can't pass props to the provider, render the payload as a JSON `<script>` tag and the provider picks it up:
+
+```tsx
+import { buildBootstrapPayload, buildBootstrapScript } from '@zenmanage/nextjs';
+
+const payload = buildBootstrapPayload(await getServerFlags({ environmentToken, context }));
+const html = buildBootstrapScript(payload); // <script id="__ZENMANAGE_BOOTSTRAP__" type="application/json">…</script>
+```
+
+The server renders without the payload, and the browser applies it right after hydration, so the first paint shows the default. Use the `bootstrapPayload` prop when you can.
+
+The other bootstrap helpers: `buildBootstrapPayload`, `serializeBootstrapPayload`, `deserializeBootstrapPayload`, `readBootstrapPayloadFromDocument`, `defaultsFromBootstrapPayload`, `defaultsFromBootstrapDocument` and `contextFromBootstrapPayload`.
+
+## Middleware
+
+`evaluateMiddlewareFlag` builds a context from the request and evaluates one flag:
+
+```ts
+// middleware.ts
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { evaluateMiddlewareFlag } from '@zenmanage/nextjs/middleware';
+
+export async function middleware(request: NextRequest) {
+  const beta = await evaluateMiddlewareFlag({
+    environmentToken: process.env.ZENMANAGE_ENVIRONMENT_TOKEN!,
+    key: 'beta-rewrite',
+    defaultValue: false,
+    request,
+  });
+
+  return beta.asBool() ? NextResponse.rewrite(new URL('/beta', request.url)) : NextResponse.next();
+}
+
+export const config = { matcher: ['/dashboard/:path*'] };
+```
+
+It works in `middleware.ts` on the Edge runtime (Next.js 13.4 and up) and in `proxy.ts` on Node.js (Next.js 16). Use a server key in both.
+
+`buildContextFromRequest(request, options)` is what builds the context. It sets:
+
+| Attribute                   | From                                                                                |
+| --------------------------- | ----------------------------------------------------------------------------------- |
+| identifier                  | the `zenmanage_user_id` cookie, then the `x-zenmanage-user-id` header               |
+| `path`                      | the request path                                                                    |
+| `user-agent`                | the `user-agent` header                                                             |
+| `country`, `region`, `city` | `request.geo`, then the `x-vercel-ip-*` headers (country also from `cf-ipcountry`)  |
+| `ip`                        | only with `includeIp: true`: `request.ip`, then `x-forwarded-for`, then `x-real-ip` |
+
+Set a different context type or name, change the cookie or header names, turn geo off, or add attributes with `contextType`, `contextName`, `identifierCookieName`, `identifierHeaderName`, `includeGeo` and `additionalAttributes`. Next.js 15 removed `request.ip` and `request.geo`, so the headers are what you get there.
+
+An IP address is personal data, which is why it's off by default.
+
+Next.js may print a build warning that `@zenmanage/sdk` uses `process.versions`, which the Edge runtime doesn't support. The SDK checks it exists before reading it, so it works. The warning is cosmetic.
+
+## Examples
+
+See [examples/README.md](examples/README.md). They cover Server Components, route handlers, `getServerSideProps`, the client provider and middleware, plus the usual targeting, defaults and rollout cases.
+
+`examples/smoke-app` is a real Next.js app that `npm run test:smoke` builds from the packed package and runs against a mock Zenmanage API.
+
+## Development
+
+```bash
+npm install
+npm run validate
+```
+
+Useful commands:
+
+- `npm run lint`
+- `npm run type-check`
+- `npm run test:coverage`
+- `npm run build`
+- `npm run test:smoke` builds the package and checks it in a real Next.js app. Set `SMOKE_NEXT_VERSION` (for example `14`) to try another Next.js version, or `SMOKE_SERVE=1` to keep the app running so you can open it in a browser. Needs `openssl`.
+
+## License
+
+MIT

package/dist/chunk-HDORXS72.js

@@ -0,0 +1,109 @@
+import {
+  getServerFlag
+} from "./chunk-PHODKVFM.js";
+
+// src/middleware.ts
+import { Attribute, Context } from "@zenmanage/sdk";
+function getCookieValue(cookies, name) {
+  if (!cookies) {
+    return void 0;
+  }
+  const value = cookies.get(name);
+  if (typeof value === "string") {
+    return value;
+  }
+  return value?.value;
+}
+function getRequestPath(request) {
+  if (request.nextUrl?.pathname) {
+    return request.nextUrl.pathname;
+  }
+  if (request.url) {
+    return new URL(request.url).pathname;
+  }
+  return "/";
+}
+function decodeHeader(value) {
+  if (!value) {
+    return void 0;
+  }
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function getIp(request) {
+  if (request.ip) {
+    return request.ip;
+  }
+  const forwarded = request.headers.get("x-forwarded-for")?.split(",")[0]?.trim();
+  return forwarded || request.headers.get("x-real-ip") || void 0;
+}
+function getGeo(request) {
+  const { headers, geo } = request;
+  return {
+    country: geo?.country || headers.get("x-vercel-ip-country") || headers.get("cf-ipcountry") || void 0,
+    region: geo?.region || headers.get("x-vercel-ip-country-region") || void 0,
+    city: geo?.city || decodeHeader(headers.get("x-vercel-ip-city"))
+  };
+}
+function buildContextFromRequest(request, options = {}) {
+  const identifierCookieName = options.identifierCookieName ?? "zenmanage_user_id";
+  const identifierHeaderName = options.identifierHeaderName ?? "x-zenmanage-user-id";
+  const includeGeo = options.includeGeo ?? true;
+  const includeIp = options.includeIp ?? false;
+  const identifier = getCookieValue(request.cookies, identifierCookieName) ?? request.headers.get(identifierHeaderName) ?? void 0;
+  const context = new Context(options.contextType ?? "user", options.contextName, identifier);
+  const userAgent = request.headers.get("user-agent");
+  if (userAgent) {
+    context.addAttribute(new Attribute("user-agent", [userAgent]));
+  }
+  context.addAttribute(new Attribute("path", [getRequestPath(request)]));
+  const ip = includeIp ? getIp(request) : void 0;
+  if (ip) {
+    context.addAttribute(new Attribute("ip", [ip]));
+  }
+  if (includeGeo) {
+    const geo = getGeo(request);
+    if (geo.country) {
+      context.addAttribute(new Attribute("country", [geo.country]));
+    }
+    if (geo.region) {
+      context.addAttribute(new Attribute("region", [geo.region]));
+    }
+    if (geo.city) {
+      context.addAttribute(new Attribute("city", [geo.city]));
+    }
+  }
+  if (options.additionalAttributes) {
+    for (const [key, value] of Object.entries(options.additionalAttributes)) {
+      if (!value) {
+        continue;
+      }
+      const values = Array.isArray(value) ? value : [value];
+      context.addAttribute(new Attribute(key, values));
+    }
+  }
+  return context;
+}
+async function evaluateMiddlewareFlag(input) {
+  const context = buildContextFromRequest(input.request, input.requestContext);
+  return getServerFlag({
+    environmentToken: input.environmentToken,
+    apiEndpoint: input.apiEndpoint,
+    cacheTtl: input.cacheTtl,
+    enableUsageReporting: input.enableUsageReporting,
+    logger: input.logger,
+    key: input.key,
+    defaultValue: input.defaultValue,
+    defaults: input.defaults,
+    context
+  });
+}
+
+export {
+  buildContextFromRequest,
+  evaluateMiddlewareFlag
+};
+//# sourceMappingURL=chunk-HDORXS72.js.map

package/dist/chunk-HDORXS72.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/middleware.ts"],"sourcesContent":["import { Attribute, Context, type Flag } from '@zenmanage/sdk';\nimport { getServerFlag } from './server';\nimport type {\n  BuildRequestContextOptions,\n  MiddlewareFlagInput,\n  RequestCookiesLike,\n  RequestLike,\n} from './types';\n\nfunction getCookieValue(cookies: RequestCookiesLike | undefined, name: string): string | undefined {\n  if (!cookies) {\n    return undefined;\n  }\n\n  const value = cookies.get(name);\n  if (typeof value === 'string') {\n    return value;\n  }\n\n  return value?.value;\n}\n\nfunction getRequestPath(request: RequestLike): string {\n  if (request.nextUrl?.pathname) {\n    return request.nextUrl.pathname;\n  }\n\n  if (request.url) {\n    return new URL(request.url).pathname;\n  }\n\n  return '/';\n}\n\nfunction decodeHeader(value: string | null): string | undefined {\n  if (!value) {\n    return undefined;\n  }\n\n  try {\n    return decodeURIComponent(value);\n  } catch {\n    return value;\n  }\n}\n\n// Next.js 15 removed `request.ip` and `request.geo`, so read what the platform forwards.\nfunction getIp(request: RequestLike): string | undefined {\n  if (request.ip) {\n    return request.ip;\n  }\n\n  const forwarded = request.headers.get('x-forwarded-for')?.split(',')[0]?.trim();\n  return forwarded || request.headers.get('x-real-ip') || undefined;\n}\n\nfunction getGeo(request: RequestLike): { country?: string; region?: string; city?: string } {\n  const { headers, geo } = request;\n\n  // Next.js 14 and earlier set `request.geo` even when nothing fills it in (it is `{}` when\n  // self-hosted), so each field falls back to the headers on its own.\n  return {\n    country:\n      geo?.country ||\n      headers.get('x-vercel-ip-country') ||\n      headers.get('cf-ipcountry') ||\n      undefined,\n    region: geo?.region || headers.get('x-vercel-ip-country-region') || undefined,\n    city: geo?.city || decodeHeader(headers.get('x-vercel-ip-city')),\n  };\n}\n\n/**\n * Builds an evaluation context from a request: an identifier (cookie, then header), the path,\n * the user agent and, when the platform reports it, the visitor's location. Works with\n * `NextRequest` and with a plain `Request`.\n */\nexport function buildContextFromRequest(\n  request: RequestLike,\n  options: BuildRequestContextOptions = {}\n): Context {\n  const identifierCookieName = options.identifierCookieName ?? 'zenmanage_user_id';\n  const identifierHeaderName = options.identifierHeaderName ?? 'x-zenmanage-user-id';\n  const includeGeo = options.includeGeo ?? true;\n  const includeIp = options.includeIp ?? false;\n\n  const identifier =\n    getCookieValue(request.cookies, identifierCookieName) ??\n    request.headers.get(identifierHeaderName) ??\n    undefined;\n\n  const context = new Context(options.contextType ?? 'user', options.contextName, identifier);\n\n  const userAgent = request.headers.get('user-agent');\n  if (userAgent) {\n    context.addAttribute(new Attribute('user-agent', [userAgent]));\n  }\n\n  context.addAttribute(new Attribute('path', [getRequestPath(request)]));\n\n  const ip = includeIp ? getIp(request) : undefined;\n  if (ip) {\n    context.addAttribute(new Attribute('ip', [ip]));\n  }\n\n  if (includeGeo) {\n    const geo = getGeo(request);\n\n    if (geo.country) {\n      context.addAttribute(new Attribute('country', [geo.country]));\n    }\n\n    if (geo.region) {\n      context.addAttribute(new Attribute('region', [geo.region]));\n    }\n\n    if (geo.city) {\n      context.addAttribute(new Attribute('city', [geo.city]));\n    }\n  }\n\n  if (options.additionalAttributes) {\n    for (const [key, value] of Object.entries(options.additionalAttributes)) {\n      if (!value) {\n        continue;\n      }\n\n      const values = Array.isArray(value) ? value : [value];\n      context.addAttribute(new Attribute(key, values));\n    }\n  }\n\n  return context;\n}\n\n/**\n * Evaluates one flag for the request. Runs on the Edge runtime (`middleware.ts`) and on the\n * Node.js runtime (`proxy.ts` in Next.js 16), and needs a server key in both.\n */\nexport async function evaluateMiddlewareFlag(input: MiddlewareFlagInput): Promise<Flag> {\n  const context = buildContextFromRequest(input.request, input.requestContext);\n\n  return getServerFlag({\n    environmentToken: input.environmentToken,\n    apiEndpoint: input.apiEndpoint,\n    cacheTtl: input.cacheTtl,\n    enableUsageReporting: input.enableUsageReporting,\n    logger: input.logger,\n    key: input.key,\n    defaultValue: input.defaultValue,\n    defaults: input.defaults,\n    context,\n  });\n}\n"],"mappings":"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","names":[]}