@naeil/ui 0.9.0 → 0.11.0

package/dist/naeil-locale/ja-DKIEQUG7.js

@@ -0,0 +1,86 @@
+import "./chunk-N3ETBM74.js";
+
+// src/naeil-locale/messages/ja.json
+var naeil = {
+  header: {
+    nav: {
+      home: "\u30DB\u30FC\u30E0",
+      projects: "\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8",
+      blog: "\u30D6\u30ED\u30B0",
+      navigation: "\u30E1\u30A4\u30F3\u30CA\u30D3\u30B2\u30FC\u30B7\u30E7\u30F3",
+      menu: "\u30E1\u30CB\u30E5\u30FC",
+      closeMenu: "\u30E1\u30CB\u30E5\u30FC\u3092\u9589\u3058\u308B"
+    },
+    theme: {
+      switchToLight: "\u30E9\u30A4\u30C8\u30C6\u30FC\u30DE\u306B\u5207\u308A\u66FF\u3048\u308B",
+      switchToDark: "\u30C0\u30FC\u30AF\u30C6\u30FC\u30DE\u306B\u5207\u308A\u66FF\u3048\u308B"
+    },
+    locale: {
+      switchLabel: "\u8A00\u8A9E"
+    },
+    projects: {
+      cc: {
+        name: "Content Collector",
+        description: "RSS\u3001YouTube\u3001Reddit\u306E\u81EA\u52D5\u53CE\u96C6 + AI\u8981\u7D04"
+      },
+      pkm: {
+        name: "PKM",
+        description: "\u500B\u4EBA\u30CA\u30EC\u30C3\u30B8\u7BA1\u7406 \u2014 \u30C9\u30AD\u30E5\u30E1\u30F3\u30C8\u89E3\u6790\u3001\u57CB\u3081\u8FBC\u307F\u3001\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u691C\u7D22"
+      },
+      naeilUi: {
+        name: "naeil-ui",
+        description: "\u30DF\u30CB\u30DE\u30EB\u30C7\u30B6\u30A4\u30F3\u30B7\u30B9\u30C6\u30E0 \u2014 OKLCH\u30C8\u30FC\u30AF\u30F3\u3001Tailwind v4\u3001shadcn"
+      },
+      sa: {
+        name: "Sustainability Analyzer",
+        description: "ESG\u30EC\u30DD\u30FC\u30C8AI\u5206\u6790 \u2014 PDF\u89E3\u6790\u3001\u5B9A\u6027\u8A55\u4FA1\u3001\u6BD4\u8F03\u8868\u306E\u81EA\u52D5\u751F\u6210"
+      },
+      babyAgent: {
+        name: "Baby Agent",
+        description: "\u80B2\u5150AI\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8 \u2014 LINE Q&A\u3001\u8A18\u9332\u3001\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC"
+      },
+      status: {
+        active: "\u30A2\u30AF\u30C6\u30A3\u30D6",
+        coming: "\u6E96\u5099\u4E2D"
+      }
+    }
+  },
+  account: {
+    menu: "\u30A2\u30AB\u30A6\u30F3\u30C8\u30E1\u30CB\u30E5\u30FC",
+    account: "\u30A2\u30AB\u30A6\u30F3\u30C8",
+    login: "\u30ED\u30B0\u30A4\u30F3",
+    logout: "\u30ED\u30B0\u30A2\u30A6\u30C8",
+    busy: "\u30ED\u30B0\u30A2\u30A6\u30C8\u4E2D\u2026"
+  },
+  footer: {
+    navigation: "\u30CA\u30D3\u30B2\u30FC\u30B7\u30E7\u30F3",
+    projects: "\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8",
+    blog: "\u30D6\u30ED\u30B0",
+    social: "\u30BD\u30FC\u30B7\u30E3\u30EB",
+    description: "Tomorrow starts here."
+  },
+  locale: {
+    names: {
+      en: "English",
+      ko: "\uD55C\uAD6D\uC5B4",
+      ja: "\u65E5\u672C\u8A9E"
+    },
+    pending: "\u8A00\u8A9E\u3092\u5909\u66F4\u3057\u3066\u3044\u307E\u3059\u2026",
+    failed: "\u8A00\u8A9E\u3092\u5909\u66F4\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u4F5C\u696D\u5185\u5BB9\u306F\u4FDD\u6301\u3055\u308C\u3066\u3044\u307E\u3059\u3002",
+    retry: "\u518D\u8A66\u884C",
+    errors: {
+      badRequest: "\u3053\u306E\u30A2\u30C9\u30EC\u30B9\u306F\u7121\u52B9\u3067\u3059\u3002",
+      notFound: "\u30DA\u30FC\u30B8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+      unauthenticated: "\u7D9A\u3051\u308B\u306B\u306F\u30ED\u30B0\u30A4\u30F3\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+      forbidden: "\u3053\u306E\u30DA\u30FC\u30B8\u3078\u306E\u30A2\u30AF\u30BB\u30B9\u6A29\u9650\u304C\u3042\u308A\u307E\u305B\u3093\u3002",
+      unavailable: "\u30B5\u30FC\u30D3\u30B9\u3092\u4E00\u6642\u7684\u306B\u5229\u7528\u3067\u304D\u307E\u305B\u3093\u3002\u3082\u3046\u4E00\u5EA6\u304A\u8A66\u3057\u304F\u3060\u3055\u3044\u3002"
+    }
+  }
+};
+var ja_default = {
+  naeil
+};
+export {
+  ja_default as default,
+  naeil
+};

package/dist/naeil-locale/ko-CY6663RZ.js

@@ -0,0 +1,86 @@
+import "./chunk-N3ETBM74.js";
+
+// src/naeil-locale/messages/ko.json
+var naeil = {
+  header: {
+    nav: {
+      home: "\uD648",
+      projects: "\uD504\uB85C\uC81D\uD2B8",
+      blog: "\uBE14\uB85C\uADF8",
+      navigation: "\uC8FC\uC694 \uBA54\uB274",
+      menu: "\uBA54\uB274",
+      closeMenu: "\uBA54\uB274 \uB2EB\uAE30"
+    },
+    theme: {
+      switchToLight: "\uBC1D\uC740 \uD14C\uB9C8\uB85C \uC804\uD658",
+      switchToDark: "\uC5B4\uB450\uC6B4 \uD14C\uB9C8\uB85C \uC804\uD658"
+    },
+    locale: {
+      switchLabel: "\uC5B8\uC5B4"
+    },
+    projects: {
+      cc: {
+        name: "Content Collector",
+        description: "RSS, YouTube, Reddit \uC790\uB3D9 \uC218\uC9D1 + AI \uC694\uC57D"
+      },
+      pkm: {
+        name: "PKM",
+        description: "\uAC1C\uC778 \uC9C0\uC2DD \uAD00\uB9AC \u2014 \uBB38\uC11C \uD30C\uC2F1, \uC784\uBCA0\uB529, \uC2DC\uB9E8\uD2F1 \uAC80\uC0C9"
+      },
+      naeilUi: {
+        name: "naeil-ui",
+        description: "\uBBF8\uB2C8\uBA40 \uB514\uC790\uC778 \uC2DC\uC2A4\uD15C \u2014 OKLCH \uD1A0\uD070, Tailwind v4, shadcn"
+      },
+      sa: {
+        name: "Sustainability Analyzer",
+        description: "ESG \uB9AC\uD3EC\uD2B8 AI \uBD84\uC11D \u2014 PDF \uD30C\uC2F1, \uC815\uC131\uD3C9\uAC00, \uBE44\uAD50\uD45C \uC790\uB3D9 \uC0DD\uC131"
+      },
+      babyAgent: {
+        name: "Baby Agent",
+        description: "\uC721\uC544 AI \uC5D0\uC774\uC804\uD2B8 \u2014 LINE \uAE30\uBC18 Q&A, \uAE30\uB85D, \uB9AC\uB9C8\uC778\uB354"
+      },
+      status: {
+        active: "\uD65C\uC131",
+        coming: "\uC900\uBE44 \uC911"
+      }
+    }
+  },
+  account: {
+    menu: "\uACC4\uC815 \uBA54\uB274",
+    account: "\uACC4\uC815",
+    login: "\uB85C\uADF8\uC778",
+    logout: "\uB85C\uADF8\uC544\uC6C3",
+    busy: "\uB85C\uADF8\uC544\uC6C3 \uC911\u2026"
+  },
+  footer: {
+    navigation: "\uB124\uBE44\uAC8C\uC774\uC158",
+    projects: "\uD504\uB85C\uC81D\uD2B8",
+    blog: "\uBE14\uB85C\uADF8",
+    social: "\uC18C\uC15C",
+    description: "Tomorrow starts here."
+  },
+  locale: {
+    names: {
+      en: "English",
+      ko: "\uD55C\uAD6D\uC5B4",
+      ja: "\u65E5\u672C\u8A9E"
+    },
+    pending: "\uC5B8\uC5B4\uB97C \uBCC0\uACBD\uD558\uB294 \uC911\u2026",
+    failed: "\uC5B8\uC5B4\uB97C \uBCC0\uACBD\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. \uC791\uC5C5 \uB0B4\uC6A9\uC740 \uC720\uC9C0\uB429\uB2C8\uB2E4.",
+    retry: "\uB2E4\uC2DC \uC2DC\uB3C4",
+    errors: {
+      badRequest: "\uC62C\uBC14\uB974\uC9C0 \uC54A\uC740 \uC8FC\uC18C\uC785\uB2C8\uB2E4.",
+      notFound: "\uD398\uC774\uC9C0\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
+      unauthenticated: "\uACC4\uC18D\uD558\uB824\uBA74 \uB85C\uADF8\uC778\uD558\uC138\uC694.",
+      forbidden: "\uC774 \uD398\uC774\uC9C0\uC5D0 \uC811\uADFC\uD560 \uAD8C\uD55C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.",
+      unavailable: "\uC77C\uC2DC\uC801\uC73C\uB85C \uC11C\uBE44\uC2A4\uB97C \uC774\uC6A9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uB2E4\uC2DC \uC2DC\uB3C4\uD558\uC138\uC694."
+    }
+  }
+};
+var ko_default = {
+  naeil
+};
+export {
+  ko_default as default,
+  naeil
+};

package/dist/naeil-locale/messages-BuQvB-u2.d.ts

@@ -0,0 +1,167 @@
+/** Opt-in owned-service routing. The legacy public i18n/routing entry is unchanged. */
+declare const naeilLocales: readonly ["en", "ko", "ja"];
+type NaeilLocale = (typeof naeilLocales)[number];
+declare const defaultLocale: NaeilLocale;
+declare const naeilRouting: {
+    locales: readonly ["en", "ko", "ja"];
+    defaultLocale: "en";
+    localePrefix: "as-needed";
+    localeDetection: false;
+    localeCookie: false;
+    alternateLinks: false;
+};
+declare function isNaeilLocale(value: unknown): value is NaeilLocale;
+declare function assertLocale(value: unknown): NaeilLocale;
+type NaeilServiceId = "main" | "jev" | "estimate" | "abstorm";
+interface NaeilRoute {
+    path: string;
+    protected?: boolean;
+}
+interface NaeilLocaleService {
+    id: NaeilServiceId;
+    origin: string;
+    routes: readonly (string | NaeilRoute)[];
+    protocolPrefixes?: readonly string[];
+    /** Explicitly audited UI routes within an otherwise protected namespace. */
+    uiProtocolExceptions?: readonly string[];
+}
+declare function defineLocaleService(service: NaeilLocaleService): NaeilLocaleService;
+declare const naeilServices: {
+    readonly abstorm: NaeilLocaleService;
+    readonly main: NaeilLocaleService;
+    readonly site: NaeilLocaleService;
+    readonly jev: NaeilLocaleService;
+    readonly estimate: NaeilLocaleService;
+};
+type LocaleServiceInput = NaeilLocaleService | NaeilServiceId;
+declare function getLocaleService(service: LocaleServiceInput): NaeilLocaleService;
+interface ResolvedLocaleRoute {
+    kind: "ui";
+    locale: NaeilLocale;
+    logicalPath: string;
+    route: NaeilRoute;
+    /** Canonical same-origin path, preserving non-language query and fragment. */
+    canonicalPath: string;
+    originalPath: string;
+    alias: boolean;
+}
+type LocaleUrlResolution = ResolvedLocaleRoute | {
+    kind: "protocol";
+    pathname: string;
+} | {
+    kind: "invalid";
+    status: 400 | 404;
+    reason: string;
+    locale?: NaeilLocale;
+};
+/** Strict UI classification is not an auth/return validator. Call existing security validators separately. */
+declare function resolveLocaleUrl(inputService: LocaleServiceInput, input: string): LocaleUrlResolution;
+/** Input must be an unlocalized registered UI route. Does not validate login return destinations. */
+declare function localePath(inputService: LocaleServiceInput, unlocalizedRoute: string, locale: NaeilLocale): string;
+declare function localeHref(service: LocaleServiceInput, unlocalizedRoute: string, locale: NaeilLocale): string;
+declare function sameLogicalRoute(service: LocaleServiceInput, left: string, right: string): boolean;
+
+declare var naeil: {
+    header: {
+        nav: {
+            home: string;
+            projects: string;
+            blog: string;
+            navigation: string;
+            menu: string;
+            closeMenu: string;
+        };
+        theme: {
+            switchToLight: string;
+            switchToDark: string;
+        };
+        locale: {
+            switchLabel: string;
+        };
+        projects: {
+            cc: {
+                name: string;
+                description: string;
+            };
+            pkm: {
+                name: string;
+                description: string;
+            };
+            naeilUi: {
+                name: string;
+                description: string;
+            };
+            sa: {
+                name: string;
+                description: string;
+            };
+            babyAgent: {
+                name: string;
+                description: string;
+            };
+            status: {
+                active: string;
+                coming: string;
+            };
+        };
+    };
+    account: {
+        menu: string;
+        account: string;
+        login: string;
+        logout: string;
+        busy: string;
+    };
+    footer: {
+        navigation: string;
+        projects: string;
+        blog: string;
+        social: string;
+        description: string;
+    };
+    locale: {
+        names: {
+            en: string;
+            ko: string;
+            ja: string;
+        };
+        pending: string;
+        failed: string;
+        retry: string;
+        errors: {
+            badRequest: string;
+            notFound: string;
+            unauthenticated: string;
+            forbidden: string;
+            unavailable: string;
+        };
+    };
+};
+declare var en: {
+    naeil: typeof naeil;
+};
+
+declare const __messages_en_json_naeil: typeof naeil;
+declare namespace __messages_en_json {
+  export { en as default, __messages_en_json_naeil as naeil };
+}
+
+interface LocaleMessages {
+    [key: string]: string | LocaleMessages;
+}
+type MessageModule = LocaleMessages | {
+    default: LocaleMessages;
+};
+type LocaleMessageLoaders = Record<NaeilLocale, () => Promise<MessageModule>>;
+type SharedMessages = typeof __messages_en_json;
+declare function loadSharedMessages(locale: NaeilLocale): Promise<SharedMessages>;
+/** Every application dictionary has exactly its declared top-level namespace. */
+declare function mergeLocaleMessages(shared: LocaleMessages, application: LocaleMessages, namespace: string): LocaleMessages;
+declare function createLocaleMessageLoader(options: {
+    namespace: string;
+    messages: LocaleMessageLoaders;
+}): (locale: NaeilLocale) => Promise<LocaleMessages>;
+/** Runtime fallback is observable and is not a substitute for the build checker. */
+declare function recoverMissingMessages(selected: LocaleMessages, english: LocaleMessages, onMissing: (key: string) => void, prefix?: string): LocaleMessages;
+
+export { type LocaleMessages as L, type MessageModule as M, type NaeilLocale as N, type ResolvedLocaleRoute as R, type SharedMessages as S, type LocaleServiceInput as a, type LocaleMessageLoaders as b, type LocaleUrlResolution as c, type NaeilLocaleService as d, type NaeilRoute as e, type NaeilServiceId as f, assertLocale as g, defaultLocale as h, defineLocaleService as i, getLocaleService as j, isNaeilLocale as k, localeHref as l, localePath as m, naeilLocales as n, naeilRouting as o, naeilServices as p, createLocaleMessageLoader as q, resolveLocaleUrl as r, sameLogicalRoute as s, loadSharedMessages as t, mergeLocaleMessages as u, recoverMissingMessages as v };

package/dist/naeil-locale/messages.d.ts

@@ -0,0 +1 @@
+export { b as LocaleMessageLoaders, L as LocaleMessages, M as MessageModule, S as SharedMessages, q as createLocaleMessageLoader, t as loadSharedMessages, u as mergeLocaleMessages, v as recoverMissingMessages } from './messages-BuQvB-u2.js';

package/dist/naeil-locale/messages.js

@@ -0,0 +1,14 @@
+import {
+  createLocaleMessageLoader,
+  loadSharedMessages,
+  mergeLocaleMessages,
+  recoverMissingMessages
+} from "./chunk-4U64K4J3.js";
+import "./chunk-U65OQHZY.js";
+import "./chunk-N3ETBM74.js";
+export {
+  createLocaleMessageLoader,
+  loadSharedMessages,
+  mergeLocaleMessages,
+  recoverMissingMessages
+};

package/dist/naeil-locale/server.d.ts

@@ -0,0 +1,75 @@
+import * as next_intl_server from 'next-intl/server';
+import { NextResponse, NextRequest } from 'next/server';
+import { a as LocaleServiceInput, R as ResolvedLocaleRoute, N as NaeilLocale, b as LocaleMessageLoaders } from './messages-BuQvB-u2.js';
+export { q as createLocaleMessageLoader, o as naeilRouting } from './messages-BuQvB-u2.js';
+
+declare const localeRequestHeader: string;
+declare const accessRequestHeader: string;
+declare const pathRequestHeader: string;
+type LocaleRequestKind = "document" | "rsc" | "action" | "other";
+declare function localeRequestKind(request: Pick<NextRequest, "method" | "headers">): LocaleRequestKind;
+/** Only read after createNaeilLocaleProxy has replaced external marker headers. */
+declare function getRequestLocale(headers: Pick<Headers, "get">, fallback?: NaeilLocale): NaeilLocale;
+/** A rendering hint, never authorization. Pages must still check data access. */
+declare function getRequestLocaleAccess(headers: Pick<Headers, "get">): "allowed" | "unauthenticated" | "forbidden" | "unavailable" | undefined;
+declare function createNaeilRequestConfig(options: {
+    namespace: string;
+    messages: LocaleMessageLoaders;
+    onMessageError?: (error: Error) => void;
+}): (params: next_intl_server.GetRequestConfigParams) => next_intl_server.RequestConfig | Promise<next_intl_server.RequestConfig>;
+interface LocaleProxyAuthorization {
+    access: "allowed" | "unauthenticated" | "forbidden" | "unavailable";
+    /** Document denial/redirect only. RSC denials render the app access boundary. */
+    response?: NextResponse;
+    /** Existing refreshed auth response; its Set-Cookie values are retained. */
+    cookiesFrom?: NextResponse;
+    /** Updated request cookies/headers from the app's existing auth refresh. */
+    requestHeaders?: Headers;
+}
+interface NaeilLocaleProxyOptions {
+    service: LocaleServiceInput;
+    /** Existing app-validated origin, e.g. a local proxy behind a trusted ingress.
+     * Never return an unvalidated forwarded Host. This is not an auth allowlist. */
+    requestOrigin?: (request: NextRequest) => string;
+    /** Runs first for exact existing protocol/security boundaries. */
+    protocol?: (request: NextRequest) => NextResponse | null | undefined | Promise<NextResponse | null | undefined>;
+    authorize?: (context: {
+        request: NextRequest;
+        route: ResolvedLocaleRoute;
+        kind: LocaleRequestKind;
+        locale: NaeilLocale;
+        logicalPath: string;
+    }) => LocaleProxyAuthorization | Promise<LocaleProxyAuthorization>;
+}
+/** Auth decisions precede alias canonicalization; no locale rewrite reaches protocol handlers. */
+declare function createNaeilLocaleProxy(options: NaeilLocaleProxyOptions): (original: NextRequest) => Promise<NextResponse>;
+declare function localeMetadata(options: {
+    service: LocaleServiceInput;
+    route: string;
+    locale: NaeilLocale;
+    title: string;
+    serviceName: string;
+    public?: boolean;
+    translatedLocales?: readonly NaeilLocale[];
+    description?: string;
+}): {
+    title: string;
+    description: string | undefined;
+    robots: {
+        index: boolean;
+        follow: boolean;
+    };
+    alternates?: undefined;
+} | {
+    title: string;
+    description: string | undefined;
+    alternates: {
+        canonical: string;
+        languages: {
+            [k: string]: string;
+        };
+    };
+    robots?: undefined;
+};
+
+export { type LocaleProxyAuthorization, type LocaleRequestKind, type NaeilLocaleProxyOptions, accessRequestHeader, createNaeilLocaleProxy, createNaeilRequestConfig, getRequestLocale, getRequestLocaleAccess, localeMetadata, localeRequestHeader, localeRequestKind, pathRequestHeader };

package/dist/naeil-locale/server.js

@@ -0,0 +1,172 @@
+import {
+  createLocaleMessageLoader,
+  loadSharedMessages,
+  recoverMissingMessages
+} from "./chunk-4U64K4J3.js";
+import {
+  assertLocale,
+  getLocaleService,
+  localeHref,
+  localePath,
+  naeilLocales,
+  naeilRouting,
+  resolveLocaleUrl
+} from "./chunk-U65OQHZY.js";
+import "./chunk-N3ETBM74.js";
+
+// src/naeil-locale/server.ts
+import "server-only";
+import { NextRequest, NextResponse } from "next/server";
+import createIntlMiddleware from "next-intl/middleware";
+import { getRequestConfig } from "next-intl/server";
+var localeRequestHeader = "x-naeil-locale";
+var accessRequestHeader = "x-naeil-locale-access";
+var pathRequestHeader = "x-naeil-locale-path";
+var privateHeaders = [localeRequestHeader, accessRequestHeader, pathRequestHeader, "x-next-intl-locale"];
+function localeRequestKind(request) {
+  if (request.headers.has("next-action")) return "action";
+  if (request.headers.get("rsc") === "1" || request.headers.has("next-router-state-tree") || request.headers.has("next-router-prefetch")) return "rsc";
+  const mode = request.headers.get("sec-fetch-mode");
+  if ((request.method === "GET" || request.method === "HEAD") && request.headers.get("sec-fetch-dest") === "empty" && (mode === "cors" || mode === "same-origin")) return "rsc";
+  return request.method === "GET" || request.method === "HEAD" ? "document" : "other";
+}
+function getRequestLocale(headers, fallback = "en") {
+  const locale = headers.get(localeRequestHeader);
+  return locale === null ? assertLocale(fallback) : assertLocale(locale);
+}
+function getRequestLocaleAccess(headers) {
+  const value = headers.get(accessRequestHeader);
+  if (value === "allowed" || value === "unauthenticated" || value === "forbidden" || value === "unavailable") return value;
+}
+function createNaeilRequestConfig(options) {
+  const load = createLocaleMessageLoader(options);
+  return getRequestConfig(async ({ requestLocale }) => {
+    var _a;
+    const locale = assertLocale((_a = await requestLocale) != null ? _a : "en");
+    const selected = await load(locale);
+    const messages = locale === "en" ? selected : recoverMissingMessages(selected, await load("en"), (key) => {
+      const error = new Error(`Missing ${locale} translation: ${key}`);
+      if (options.onMessageError) options.onMessageError(error);
+      else console.error(error.message);
+    });
+    return { locale, messages, timeZone: "UTC" };
+  });
+}
+function copyCookies(from, to) {
+  from == null ? void 0 : from.cookies.getAll().forEach((cookie) => to.cookies.set(cookie));
+  return to;
+}
+function stripMarkers(headers) {
+  const sanitized = new Headers(headers);
+  for (const key of privateHeaders) sanitized.delete(key);
+  return sanitized;
+}
+function sanitizeProtocolPassThrough(response, requestHeaders) {
+  var _a;
+  if (response.headers.get("x-middleware-next") !== "1" && !response.headers.has("x-middleware-rewrite")) return response;
+  const forwarded = new Headers(requestHeaders);
+  for (const key of ((_a = response.headers.get("x-middleware-override-headers")) != null ? _a : "").split(",")) {
+    if (!key) continue;
+    const value = response.headers.get(`x-middleware-request-${key}`);
+    if (value !== null) forwarded.set(key, value);
+  }
+  for (const key of privateHeaders) {
+    forwarded.delete(key);
+    response.headers.delete(`x-middleware-request-${key}`);
+  }
+  const names = [];
+  for (const [key, value] of forwarded) {
+    names.push(key);
+    response.headers.set(`x-middleware-request-${key}`, value);
+  }
+  response.headers.set("x-middleware-override-headers", names.join(","));
+  return response;
+}
+function markPrivate(response) {
+  response.headers.set("Cache-Control", "private, no-store");
+  return response;
+}
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[char]);
+}
+async function invalidResponse(status, service, kind, locale = "en") {
+  if (kind !== "document") return markPrivate(new NextResponse(null, { status }));
+  const copy = (await loadSharedMessages(locale)).naeil.locale;
+  const message = copy.errors[status === 400 ? "badRequest" : status === 401 ? "unauthenticated" : status === 403 ? "forbidden" : status === 503 ? "unavailable" : "notFound"];
+  const id = getLocaleService(service).id;
+  const identity = { abstorm: { name: "abstorm", icon: null }, main: { name: ".naeil", icon: "/icon.svg" }, jev: { name: "Jev", icon: null }, estimate: { name: "AB Estimate", icon: "/favicon.svg" } }[id];
+  const links = naeilLocales.map((language) => `<li><a lang="${language}" href="${escapeHtml(localePath(service, "/", language))}">${escapeHtml(copy.names[language])}</a></li>`).join("");
+  return markPrivate(new NextResponse(`<!doctype html><html lang="${locale}"><head><meta name="robots" content="noindex"><meta name="viewport" content="width=device-width,initial-scale=1">${identity.icon ? `<link rel="icon" href="${identity.icon}">` : ""}<title>${escapeHtml(message)} \u2014 ${identity.name}</title></head><body><h1>${status}</h1><p>${escapeHtml(message)}</p><ul>${links}</ul></body></html>`, { status, headers: { "Content-Type": "text/html; charset=utf-8" } }));
+}
+function createNaeilLocaleProxy(options) {
+  const service = getLocaleService(options.service);
+  const intl = createIntlMiddleware(naeilRouting);
+  return async function naeilLocaleProxy(original) {
+    var _a, _b, _c, _d, _e, _f;
+    const sanitized = stripMarkers(original.headers);
+    const request = new NextRequest(original, { headers: sanitized });
+    const protocol = await ((_a = options.protocol) == null ? void 0 : _a.call(options, request));
+    if (protocol) return sanitizeProtocolPassThrough(protocol, sanitized);
+    const kind = localeRequestKind(request);
+    const raw = new URL(request.url);
+    const origin = (_c = (_b = options.requestOrigin) == null ? void 0 : _b.call(options, request)) != null ? _c : raw.origin;
+    const parsedOrigin = new URL(origin);
+    if (parsedOrigin.origin !== origin || !["https:", "http:"].includes(parsedOrigin.protocol)) throw new Error("Expected a validated HTTP request origin");
+    const result = resolveLocaleUrl(service, raw.pathname + raw.search);
+    if (result.kind === "protocol") return NextResponse.next({ request: { headers: sanitized } });
+    if (result.kind === "invalid") return invalidResponse(result.status, service, kind, result.locale);
+    const authorization = options.authorize ? await options.authorize({ request, route: result, kind, locale: result.locale, logicalPath: result.logicalPath }) : { access: result.route.protected ? "unavailable" : "allowed" };
+    const authHeaders = stripMarkers((_d = authorization.requestHeaders) != null ? _d : sanitized);
+    if (authorization.access !== "allowed" && kind === "document") {
+      return copyCookies(authorization.cookiesFrom, markPrivate((_e = authorization.response) != null ? _e : await invalidResponse(authorization.access === "unauthenticated" ? 401 : authorization.access === "forbidden" ? 403 : 503, service, kind, result.locale)));
+    }
+    if (authorization.access !== "allowed" && kind !== "rsc") return copyCookies(authorization.cookiesFrom, markPrivate(new NextResponse(null, { status: authorization.access === "unauthenticated" ? 401 : authorization.access === "forbidden" ? 403 : 503 })));
+    if (result.alias && kind === "document") return copyCookies(authorization.cookiesFrom, NextResponse.redirect(new URL(result.canonicalPath, origin), 307));
+    if (result.alias && kind !== "document") return copyCookies(authorization.cookiesFrom, await invalidResponse(400, service, kind, result.locale));
+    authHeaders.set(localeRequestHeader, result.locale);
+    authHeaders.set("x-next-intl-locale", result.locale);
+    authHeaders.set(pathRequestHeader, result.logicalPath);
+    authHeaders.set(accessRequestHeader, authorization.access);
+    const response = intl(new NextRequest(request, { headers: authHeaders }));
+    const rewrite = response.headers.get("x-middleware-rewrite");
+    if (rewrite && options.requestOrigin) {
+      const target = new URL(rewrite);
+      target.host = parsedOrigin.host;
+      target.protocol = parsedOrigin.protocol;
+      response.headers.set("x-middleware-rewrite", target.href);
+    }
+    const forwarded = new Set(((_f = response.headers.get("x-middleware-override-headers")) != null ? _f : "").split(",").filter(Boolean));
+    for (const [key, value] of authHeaders) {
+      forwarded.add(key);
+      response.headers.set(`x-middleware-request-${key}`, value);
+    }
+    response.headers.set("x-middleware-override-headers", [...forwarded].join(","));
+    response.headers.delete("link");
+    if (result.route.protected || authorization.access !== "allowed") markPrivate(response);
+    return copyCookies(authorization.cookiesFrom, response);
+  };
+}
+function localeMetadata(options) {
+  var _a;
+  const locale = assertLocale(options.locale);
+  const title = options.title ? `${options.title} \u2014 ${options.serviceName}` : options.serviceName;
+  if (!options.public) return { title, description: options.description, robots: { index: false, follow: false } };
+  const translated = (_a = options.translatedLocales) != null ? _a : naeilLocales;
+  if (!translated.includes(locale)) throw new Error("Cannot advertise untranslated page");
+  const languages = Object.fromEntries(translated.map((language) => [language, localeHref(options.service, options.route, language)]));
+  if (translated.includes("en")) languages["x-default"] = localeHref(options.service, options.route, "en");
+  return { title, description: options.description, alternates: { canonical: localeHref(options.service, options.route, locale), languages } };
+}
+export {
+  accessRequestHeader,
+  createLocaleMessageLoader,
+  createNaeilLocaleProxy,
+  createNaeilRequestConfig,
+  getRequestLocale,
+  getRequestLocaleAccess,
+  localeMetadata,
+  localeRequestHeader,
+  localeRequestKind,
+  naeilRouting,
+  pathRequestHeader
+};

package/dist/source/components/naeil-footer-core.d.ts

@@ -0,0 +1,16 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { SiteFooterProps } from './ui/site-footer.js';
+import { NaeilHeaderLocale } from './naeil-header-data.js';
+import 'react';
+import './ui/navigation.js';
+
+type NaeilFooterLocale = NaeilHeaderLocale;
+interface NaeilFooterProps extends Omit<SiteFooterProps, "brand" | "description" | "groups"> {
+    locale: NaeilFooterLocale;
+    /** Only localize/route canonical paths; default destinations use the official origin. */
+    resolveHref?: (path: string) => string;
+}
+/** Canonical content in full/compact density. Product legal/status copy belongs in meta. */
+declare function NaeilFooter({ locale, resolveHref, variant, Link, onNavigate, ...props }: NaeilFooterProps): react_jsx_runtime.JSX.Element;
+
+export { NaeilFooter, type NaeilFooterLocale, type NaeilFooterProps };