@kanzo-tech/navigation 0.11.0

package/README.md

@@ -0,0 +1,44 @@
+# @kanzo-tech/navigation
+
+An unsaved-changes guard: one hook, `useBlocker`, in TanStack Router's shape, over the Navigation
+API and `beforeunload` — and a `/next` door for the two App Router navigations the browser cannot
+see in time.
+
+```sh
+pnpm add @kanzo-tech/navigation
+```
+
+```tsx
+import { useBlocker } from "@kanzo-tech/navigation";
+import { Link, useRouter } from "@kanzo-tech/navigation/next";
+
+const blocker = useBlocker({ shouldBlockFn: () => true, disabled: !dirty, withResolver: true });
+// blocker.status === "blocked" → show your AlertDialog; blocker.proceed() leaves, blocker.reset() stays.
+```
+
+## What it is not
+
+**There is no dialog and no copy.** `status`, `proceed` and `reset` drive the product's own
+`AlertDialog`, in the product's own words.
+
+**Nothing is patched.** No `history.pushState`, no router internals, no document-level click
+capture. Every navigation is either cancelled through a public API or documented as not covered —
+the table is at <https://kanzo-tech.github.io/ui/docs/navigation-guard>.
+
+## Why a package, and not `@kanzo-tech/ui`
+
+`/docs/philosophy` puts *any router integration* in the products, and nothing here draws. It
+depends on nothing of `ui`'s.
+
+## Close the door behind you
+
+A raw `next/link` or `useRouter` from `next/navigation` walks past the guard. Forbid both:
+
+```js
+"no-restricted-imports": ["error", {
+  paths: [
+    { name: "next/link", message: "Use Link from @kanzo-tech/navigation/next." },
+    { name: "next/navigation", importNames: ["useRouter"], message: "Use useRouter from @kanzo-tech/navigation/next." },
+  ],
+}],
+```

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `@kanzo-tech/navigation` — keeping somebody on a page they have not finished with.
+ *
+ * One hook, `useBlocker`, in TanStack Router's shape. This door is the browser half and knows no
+ * router: back, forward and `history.go` are cancelled through the Navigation API's `navigate`
+ * event before they commit, a plain `<a>` or `location.assign` the same way, and reload, close and
+ * the URL bar through `beforeunload`. A router's own client navigations are its adapter's —
+ * `@kanzo-tech/navigation/next` for the App Router.
+ *
+ * There is no dialog here and no copy. `status`, `proceed` and `reset` drive the product's own
+ * `AlertDialog`, in the product's words.
+ *
+ * Nothing in this package patches `history`, reads a router's internals, or listens for clicks on
+ * the document. `/docs/design/navigation` has each of those and why.
+ */
+export { useBlocker } from './use-blocker';
+export type { BlockerResolver, HistoryAction, ShouldBlockFn, ShouldBlockFnArgs, ShouldBlockFnLocation, UseBlockerOpts, } from './types';
+//# 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;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,YAAY,EACV,eAAe,EACf,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,cAAc,GACf,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+import { useBlocker as r } from "./use-blocker.js";
+export {
+  r as useBlocker
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/next-link.d.ts

@@ -0,0 +1,16 @@
+import { default as NextLink } from 'next/link';
+import { ComponentProps } from 'react';
+type LinkProps = ComponentProps<typeof NextLink>;
+/**
+ * `next/link`, with `onNavigate` consulting the blockers.
+ *
+ * `onNavigate` is the only cancellable moment Next offers a link: it runs after `Link` has
+ * prevented the click and before it dispatches. A blocker that answers `false` synchronously costs
+ * nothing — the link navigates as it would have. Any other answer cancels now, and a `proceed`
+ * re-issues the navigation through `router.push` or `router.replace` with the same `scroll`. The
+ * re-issued one does not carry `useLinkStatus`'s pending state; that is the price of a decision
+ * that could not be made synchronously.
+ */
+export declare function Link(props: LinkProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=next-link.d.ts.map

package/dist/next-link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-link.d.ts","sourceRoot":"","sources":["../src/next-link.tsx"],"names":[],"mappings":"AAEA,OAAO,QAAQ,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAU,KAAK,cAAc,EAAE,MAAM,OAAO,CAAC;AAGpD,KAAK,SAAS,GAAG,cAAc,CAAC,OAAO,QAAQ,CAAC,CAAC;AAyBjD;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,SAAS,+BA0CpC"}

package/dist/next-link.js

@@ -0,0 +1,56 @@
+"use client";
+import { jsx as v } from "react/jsx-runtime";
+import d from "next/link";
+import { useRouter as g } from "next/navigation";
+import { useRef as y } from "react";
+import { evaluate as $, locationOf as m } from "./registry.js";
+function k(n) {
+  if (typeof n == "string") return n;
+  const { pathname: u, query: o, search: s, hash: e } = n;
+  let t = s ?? "";
+  if (!t && o) {
+    const a = new URLSearchParams();
+    if (typeof o == "string") t = o;
+    else {
+      for (const [c, r] of Object.entries(o))
+        for (const i of Array.isArray(r) ? r : [r])
+          i != null && a.append(c, String(i));
+      t = a.toString();
+    }
+  }
+  t && !t.startsWith("?") && (t = `?${t}`);
+  const f = e ? e.startsWith("#") ? e : `#${e}` : "";
+  return `${u ?? ""}${t}${f}`;
+}
+function D(n) {
+  const { href: u, as: o, replace: s, scroll: e, onClick: t, onNavigate: f } = n, a = g(), c = y(void 0);
+  return /* @__PURE__ */ v(
+    d,
+    {
+      ...n,
+      onClick: (r) => {
+        c.current = r.currentTarget.href, t == null || t(r);
+      },
+      onNavigate: (r) => {
+        let i = !1;
+        if (f == null || f({
+          preventDefault: () => {
+            i = !0, r.preventDefault();
+          }
+        }), i) return;
+        const l = k(o ?? u), p = $({
+          current: m(location.href),
+          next: m(c.current ?? l, location.href),
+          action: s ? "REPLACE" : "PUSH"
+        });
+        p !== !1 && (r.preventDefault(), p !== !0 && p.then((h) => {
+          h || (s ? a.replace(l, { scroll: e }) : a.push(l, { scroll: e }));
+        }));
+      }
+    }
+  );
+}
+export {
+  D as Link
+};
+//# sourceMappingURL=next-link.js.map

package/dist/next-link.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-link.js","sources":["../src/next-link.tsx"],"sourcesContent":["\"use client\";\n\nimport NextLink from \"next/link\";\nimport { useRouter as useNextRouter } from \"next/navigation\";\nimport { useRef, type ComponentProps } from \"react\";\nimport { evaluate, locationOf } from \"./registry\";\n\ntype LinkProps = ComponentProps<typeof NextLink>;\ntype Href = LinkProps[\"href\"];\n\n/** The URL a `Link` goes to, spelled the way `router.push` takes it. */\nfunction hrefOf(href: Href): string {\n  if (typeof href === \"string\") return href;\n  const { pathname, query, search, hash } = href;\n  let tail = search ?? \"\";\n  if (!tail && query) {\n    const params = new URLSearchParams();\n    if (typeof query === \"string\") tail = query;\n    else {\n      for (const [key, value] of Object.entries(query)) {\n        for (const item of Array.isArray(value) ? value : [value]) {\n          if (item !== undefined && item !== null) params.append(key, String(item));\n        }\n      }\n      tail = params.toString();\n    }\n  }\n  if (tail && !tail.startsWith(\"?\")) tail = `?${tail}`;\n  const fragment = hash ? (hash.startsWith(\"#\") ? hash : `#${hash}`) : \"\";\n  return `${pathname ?? \"\"}${tail}${fragment}`;\n}\n\n/**\n * `next/link`, with `onNavigate` consulting the blockers.\n *\n * `onNavigate` is the only cancellable moment Next offers a link: it runs after `Link` has\n * prevented the click and before it dispatches. A blocker that answers `false` synchronously costs\n * nothing — the link navigates as it would have. Any other answer cancels now, and a `proceed`\n * re-issues the navigation through `router.push` or `router.replace` with the same `scroll`. The\n * re-issued one does not carry `useLinkStatus`'s pending state; that is the price of a decision\n * that could not be made synchronously.\n */\nexport function Link(props: LinkProps) {\n  const { href, as, replace, scroll, onClick, onNavigate } = props;\n  const router = useNextRouter();\n  // The anchor's own `href` is the destination as the browser resolved it — base path, relative\n  // segments and all — which is what `shouldBlockFn` is owed. `onClick` runs just before\n  // `onNavigate`, on the same click.\n  const clicked = useRef<string | undefined>(undefined);\n\n  return (\n    <NextLink\n      {...props}\n      onClick={(event) => {\n        clicked.current = event.currentTarget.href;\n        onClick?.(event);\n      }}\n      onNavigate={(event) => {\n        let prevented = false;\n        onNavigate?.({\n          preventDefault: () => {\n            prevented = true;\n            event.preventDefault();\n          },\n        });\n        if (prevented) return;\n\n        const target = hrefOf(as ?? href);\n        const verdict = evaluate({\n          current: locationOf(location.href),\n          next: locationOf(clicked.current ?? target, location.href),\n          action: replace ? \"REPLACE\" : \"PUSH\",\n        });\n        if (verdict === false) return;\n        event.preventDefault();\n        if (verdict === true) return;\n        void verdict.then((block) => {\n          if (block) return;\n          if (replace) router.replace(target, { scroll });\n          else router.push(target, { scroll });\n        });\n      }}\n    />\n  );\n}\n"],"names":[],"mappings":";;;;;;AAWA;AACE;AACA;AACA;AACA;AACE;AACA;AAAsC;AAEpC;AACE;AACE;AAGJ;AAAc;AAChB;AAEF;AACA;AACA;AACF;AAYO;AACL;AAOA;AACE;AAAC;AAAA;AACK;AAEF;AACU;AACZ;AAEE;AAOA;AANa;AAET;AACM;AACR;AAIF;AACyB;AACU;AACwB;AAC3B;AAEhC;AAIE;AAEmC;AACpC;AACH;AAAA;AAGN;;;;"}

package/dist/next-router.d.ts

@@ -0,0 +1,12 @@
+import { useRouter as useNextRouter } from 'next/navigation';
+type Router = ReturnType<typeof useNextRouter>;
+/**
+ * `next/navigation`'s `useRouter`, with `push` and `replace` consulting the blockers first.
+ *
+ * It wraps the instance Next hands every component, and nothing below it: `back`, `forward`,
+ * `refresh` and `prefetch` are Next's own. `back` and `forward` are traversals, which the root's
+ * `navigate` listener already sees before they commit; `refresh` does not leave the page.
+ */
+export declare function useRouter(): Router;
+export {};
+//# sourceMappingURL=next-router.d.ts.map

package/dist/next-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-router.d.ts","sourceRoot":"","sources":["../src/next-router.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAK7D,KAAK,MAAM,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AAE/C;;;;;;GAMG;AACH,wBAAgB,SAAS,IAAI,MAAM,CAyBlC"}

package/dist/next-router.js

@@ -0,0 +1,29 @@
+"use client";
+import { useRouter as s } from "next/navigation";
+import { useMemo as f } from "react";
+import { evaluate as l, locationOf as c } from "./registry.js";
+function R() {
+  const e = s();
+  return f(() => {
+    const o = (i, u) => (r, n) => {
+      const t = l({
+        current: c(location.href),
+        next: c(r, location.href),
+        action: i
+      });
+      if (t === !1) return u(r, n);
+      t !== !0 && t.then((a) => {
+        a || u(r, n);
+      });
+    };
+    return {
+      ...e,
+      push: o("PUSH", e.push),
+      replace: o("REPLACE", e.replace)
+    };
+  }, [e]);
+}
+export {
+  R as useRouter
+};
+//# sourceMappingURL=next-router.js.map

package/dist/next-router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-router.js","sources":["../src/next-router.ts"],"sourcesContent":["\"use client\";\n\nimport { useRouter as useNextRouter } from \"next/navigation\";\nimport { useMemo } from \"react\";\nimport { evaluate, locationOf } from \"./registry\";\nimport type { HistoryAction } from \"./types\";\n\ntype Router = ReturnType<typeof useNextRouter>;\n\n/**\n * `next/navigation`'s `useRouter`, with `push` and `replace` consulting the blockers first.\n *\n * It wraps the instance Next hands every component, and nothing below it: `back`, `forward`,\n * `refresh` and `prefetch` are Next's own. `back` and `forward` are traversals, which the root's\n * `navigate` listener already sees before they commit; `refresh` does not leave the page.\n */\nexport function useRouter(): Router {\n  const router = useNextRouter();\n\n  return useMemo(() => {\n    const guarded =\n      (action: HistoryAction, go: Router[\"push\"]): Router[\"push\"] =>\n      (href, options) => {\n        const verdict = evaluate({\n          current: locationOf(location.href),\n          next: locationOf(href, location.href),\n          action,\n        });\n        if (verdict === false) return go(href, options);\n        if (verdict === true) return;\n        void verdict.then((block) => {\n          if (!block) go(href, options);\n        });\n      };\n\n    return {\n      ...router,\n      push: guarded(\"PUSH\", router.push),\n      replace: guarded(\"REPLACE\", router.replace),\n    };\n  }, [router]);\n}\n"],"names":[],"mappings":";;;;AAgBO;AACL;AAEA;AACE;AAGI;AAAyB;AACU;AACG;AACpC;AAEF;AACA;AAEE;AAA4B;AAC7B;AAGL;AAAO;AACF;AAC8B;AACS;AAAA;AAGhD;;;;"}

package/dist/next.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `@kanzo-tech/navigation/next` — the two App Router navigations the root cannot see.
+ *
+ * Next writes the URL of a client navigation *after* the new route has rendered, so by the time the
+ * browser reports it there is nothing left to cancel. What Next does offer is public and early:
+ * `Link`'s `onNavigate`, and the router a component asks for. This door is those two, wired to the
+ * same blockers `useBlocker` registers.
+ *
+ * ```ts
+ * import { Link, useRouter } from "@kanzo-tech/navigation/next";
+ * ```
+ *
+ * A raw `next/link` or `useRouter` from `next/navigation` walks past both, and nothing at runtime
+ * can notice. The lint rule that closes that is on `/docs/navigation-guard/next`.
+ */
+export { Link } from './next-link';
+export { useRouter } from './next-router';
+//# sourceMappingURL=next.d.ts.map

package/dist/next.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.d.ts","sourceRoot":"","sources":["../src/next.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACnC,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC"}

package/dist/next.js

@@ -0,0 +1,7 @@
+import { Link as e } from "./next-link.js";
+import { useRouter as f } from "./next-router.js";
+export {
+  e as Link,
+  f as useRouter
+};
+//# sourceMappingURL=next.js.map

package/dist/next.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/platform.d.ts

@@ -0,0 +1,27 @@
+import { Blocker } from './registry';
+/**
+ * The browser half: the Navigation API's `navigate` event and `beforeunload`. Nothing here knows a
+ * router, and nothing here touches `history` — every navigation is either cancelled through a
+ * public event or left alone.
+ *
+ * The listeners exist only while a blocker does. MDN: a `beforeunload` listener costs a page its
+ * back/forward cache in Firefox, so a page with nothing to protect must carry none.
+ */
+/** The slice of the Navigation API this reads. TypeScript's DOM lib does not declare it yet. */
+interface HistoryEntry {
+    key: string;
+    index: number;
+    url: string | null;
+}
+export interface Navigation extends EventTarget {
+    currentEntry: HistoryEntry | null;
+    navigate(url: string, options?: {
+        history?: "push" | "replace";
+        state?: unknown;
+    }): unknown;
+    traverseTo(key: string): unknown;
+}
+/** Adds a blocker at the end of the order and returns what removes it. */
+export declare function register(blocker: Blocker): () => void;
+export {};
+//# sourceMappingURL=platform.d.ts.map

package/dist/platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../src/platform.ts"],"names":[],"mappings":"AAEA,OAAO,EAA0C,KAAK,OAAO,EAAE,MAAM,YAAY,CAAC;AAGlF;;;;;;;GAOG;AAEH,gGAAgG;AAChG,UAAU,YAAY;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACpB;AAeD,MAAM,WAAW,UAAW,SAAQ,WAAW;IAC7C,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC;IAC5F,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAClC;AAgFD,0EAA0E;AAC1E,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,IAAI,CASrD"}

package/dist/platform.js

@@ -0,0 +1,62 @@
+"use client";
+import { blockers as r, bypass as t, evaluate as d, locationOf as u } from "./registry.js";
+const o = () => window.navigation;
+function c(e, n) {
+  var a;
+  if (e.navigationType === "push") return "PUSH";
+  if (e.navigationType === "replace") return "REPLACE";
+  const i = e.destination.index - (((a = n.currentEntry) == null ? void 0 : a.index) ?? -2);
+  return i === -1 ? "BACK" : i === 1 ? "FORWARD" : "GO";
+}
+function v(e, n) {
+  if (t.navigate = !0, e.destination.sameDocument || (t.beforeunload = !0), e.navigationType === "traverse") {
+    n.traverseTo(e.destination.key);
+    return;
+  }
+  n.navigate(e.destination.url, {
+    history: e.navigationType === "replace" ? "replace" : "push",
+    state: e.destination.getState()
+  });
+}
+function f(e) {
+  const n = e, i = o();
+  if (!i) return;
+  if (t.navigate) {
+    t.navigate = !1;
+    return;
+  }
+  if (n.navigationType === "reload" || n.navigationType !== "traverse" && n.destination.sameDocument || n.formData !== null || n.downloadRequest !== null || !n.cancelable) return;
+  const a = d({
+    current: u(location.href),
+    next: u(n.destination.url),
+    action: c(n, i)
+  });
+  a !== !1 && (n.preventDefault(), a !== !0 && a.then((l) => {
+    l || v(n, i);
+  }));
+}
+function s(e) {
+  if (t.beforeunload) {
+    t.beforeunload = !1;
+    return;
+  }
+  r.some((n) => n.enableBeforeUnload()) && (e.preventDefault(), e.returnValue = "");
+}
+function g() {
+  var e;
+  window.addEventListener("beforeunload", s), (e = o()) == null || e.addEventListener("navigate", f);
+}
+function p() {
+  var e;
+  window.removeEventListener("beforeunload", s), (e = o()) == null || e.removeEventListener("navigate", f), t.navigate = !1, t.beforeunload = !1;
+}
+function m(e) {
+  return r.length === 0 && g(), r.push(e), () => {
+    const n = r.indexOf(e);
+    n !== -1 && (r.splice(n, 1), r.length === 0 && p());
+  };
+}
+export {
+  m as register
+};
+//# sourceMappingURL=platform.js.map

package/dist/platform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.js","sources":["../src/platform.ts"],"sourcesContent":["\"use client\";\n\nimport { blockers, bypass, evaluate, locationOf, type Blocker } from \"./registry\";\nimport type { HistoryAction } from \"./types\";\n\n/**\n * The browser half: the Navigation API's `navigate` event and `beforeunload`. Nothing here knows a\n * router, and nothing here touches `history` — every navigation is either cancelled through a\n * public event or left alone.\n *\n * The listeners exist only while a blocker does. MDN: a `beforeunload` listener costs a page its\n * back/forward cache in Firefox, so a page with nothing to protect must carry none.\n */\n\n/** The slice of the Navigation API this reads. TypeScript's DOM lib does not declare it yet. */\ninterface HistoryEntry {\n  key: string;\n  index: number;\n  url: string | null;\n}\n\ninterface NavigateEvent extends Event {\n  navigationType: \"push\" | \"replace\" | \"reload\" | \"traverse\";\n  destination: {\n    url: string;\n    key: string;\n    index: number;\n    sameDocument: boolean;\n    getState(): unknown;\n  };\n  formData: FormData | null;\n  downloadRequest: string | null;\n}\n\nexport interface Navigation extends EventTarget {\n  currentEntry: HistoryEntry | null;\n  navigate(url: string, options?: { history?: \"push\" | \"replace\"; state?: unknown }): unknown;\n  traverseTo(key: string): unknown;\n}\n\nconst navigationOf = (): Navigation | undefined =>\n  (window as unknown as { navigation?: Navigation }).navigation;\n\nfunction actionOf(event: NavigateEvent, navigation: Navigation): HistoryAction {\n  if (event.navigationType === \"push\") return \"PUSH\";\n  if (event.navigationType === \"replace\") return \"REPLACE\";\n  const delta = event.destination.index - (navigation.currentEntry?.index ?? -2);\n  return delta === -1 ? \"BACK\" : delta === 1 ? \"FORWARD\" : \"GO\";\n}\n\n/** Replays a navigation `proceed` allowed, past the blockers it was cancelled by. */\nfunction replay(event: NavigateEvent, navigation: Navigation) {\n  bypass.navigate = true;\n  if (!event.destination.sameDocument) bypass.beforeunload = true;\n  if (event.navigationType === \"traverse\") {\n    navigation.traverseTo(event.destination.key);\n    return;\n  }\n  navigation.navigate(event.destination.url, {\n    history: event.navigationType === \"replace\" ? \"replace\" : \"push\",\n    state: event.destination.getState(),\n  });\n}\n\nfunction onNavigate(raw: Event) {\n  const event = raw as NavigateEvent;\n  const navigation = navigationOf();\n  if (!navigation) return;\n  if (bypass.navigate) {\n    bypass.navigate = false;\n    return;\n  }\n  // A reload is `beforeunload`'s. A same-document push or replace is a router writing the URL of a\n  // page it has already rendered — too late to cancel — or a hash, which leaves nothing.\n  if (event.navigationType === \"reload\") return;\n  if (event.navigationType !== \"traverse\" && event.destination.sameDocument) return;\n  // A POST cannot be replayed through `navigation.navigate`, and a download leaves the page as it\n  // was. Both stay with the browser, which asks through `beforeunload` where it applies.\n  if (event.formData !== null || event.downloadRequest !== null) return;\n  // Browser UI, and a traversal with no history-action activation left: the platform decides.\n  if (!event.cancelable) return;\n\n  const verdict = evaluate({\n    current: locationOf(location.href),\n    next: locationOf(event.destination.url),\n    action: actionOf(event, navigation),\n  });\n  if (verdict === false) return;\n  event.preventDefault();\n  if (verdict === true) return;\n  void verdict.then((block) => {\n    if (!block) replay(event, navigation);\n  });\n}\n\nfunction onBeforeUnload(event: BeforeUnloadEvent) {\n  if (bypass.beforeunload) {\n    bypass.beforeunload = false;\n    return;\n  }\n  if (!blockers.some((blocker) => blocker.enableBeforeUnload())) return;\n  event.preventDefault();\n  // Still required by Chromium-based browsers for the dialog to show; the text itself is ignored.\n  event.returnValue = \"\";\n}\n\nfunction listen() {\n  window.addEventListener(\"beforeunload\", onBeforeUnload);\n  navigationOf()?.addEventListener(\"navigate\", onNavigate);\n}\n\nfunction unlisten() {\n  window.removeEventListener(\"beforeunload\", onBeforeUnload);\n  navigationOf()?.removeEventListener(\"navigate\", onNavigate);\n  bypass.navigate = false;\n  bypass.beforeunload = false;\n}\n\n/** Adds a blocker at the end of the order and returns what removes it. */\nexport function register(blocker: Blocker): () => void {\n  if (blockers.length === 0) listen();\n  blockers.push(blocker);\n  return () => {\n    const at = blockers.indexOf(blocker);\n    if (at === -1) return;\n    blockers.splice(at, 1);\n    if (blockers.length === 0) unlisten();\n  };\n}\n"],"names":[],"mappings":";;AAwCA;AAGA;;AACE;AACA;AACA;AACA;AACF;AAGA;AAGE;AACE;AACA;AAAA;AAEF;AAA2C;AACiB;AACjC;AAE7B;AAEA;AACE;AAEA;AACA;AACE;AACA;AAAA;AAUF;AAEA;AAAyB;AACU;AACK;AACJ;AAEpC;AAIE;AAAoC;AAExC;AAEA;AACE;AACE;AACA;AAAA;AAEF;AAIF;AAEA;;AACE;AAEF;AAEA;;AACE;AAIF;AAGO;AACL;AAGE;AACA;AAE2B;AAE/B;;;;"}

package/dist/registry.d.ts

@@ -0,0 +1,34 @@
+import { ShouldBlockFnArgs, ShouldBlockFnLocation } from './types';
+/**
+ * The blockers on the page, and the one evaluation every door shares.
+ *
+ * Module state on purpose: the root's listeners and `/next`'s `Link` and `useRouter` must consult
+ * the same list, and the build writes one file per module so both doors import this one rather than
+ * each inlining a copy. No DOM here — `platform.ts` is the half that touches `window`.
+ */
+export interface Blocker {
+    /** `true` blocks, `false` lets it through; a promise is a decision still being made. */
+    fn: (args: ShouldBlockFnArgs) => boolean | Promise<boolean>;
+    enableBeforeUnload: () => boolean;
+}
+export declare const blockers: Blocker[];
+/**
+ * One-shot passes for a navigation this package is replaying after `proceed`, so the replay is not
+ * blocked a second time. TanStack's `ignoreNextBeforeUnload` and `skipBlockerNextPop`, in the two
+ * places a replay reaches here.
+ */
+export declare const bypass: {
+    navigate: boolean;
+    beforeunload: boolean;
+};
+/**
+ * Blockers in registration order, and the first that says `true` blocks.
+ *
+ * Synchronous for as long as every blocker answers synchronously, which is what lets a clean form
+ * leave `Link` and `navigate` completely alone. A promise anywhere turns the rest of the walk into
+ * one: the caller then has to cancel now and replay later, because both hooks it sits on demand a
+ * synchronous `preventDefault()`.
+ */
+export declare function evaluate(args: ShouldBlockFnArgs): boolean | Promise<boolean>;
+export declare function locationOf(url: string | URL, base?: string): ShouldBlockFnLocation;
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAExE;;;;;;GAMG;AAEH,MAAM,WAAW,OAAO;IACtB,wFAAwF;IACxF,EAAE,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5D,kBAAkB,EAAE,MAAM,OAAO,CAAC;CACnC;AAED,eAAO,MAAM,QAAQ,EAAE,OAAO,EAAO,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,MAAM;;;CAA2C,CAAC;AAE/D;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAa5E;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,qBAAqB,CAGlF"}

package/dist/registry.js

@@ -0,0 +1,25 @@
+const a = [], l = { navigate: !1, beforeunload: !1 };
+function u(n) {
+  const e = (t) => {
+    const r = a.slice(t);
+    for (const [o, s] of r.entries()) {
+      const f = s.fn(n);
+      if (f === !0) return !0;
+      if (f !== !1)
+        return Promise.resolve(f).then((c) => c ? !0 : e(t + o + 1));
+    }
+    return !1;
+  };
+  return e(0);
+}
+function i(n, e) {
+  const { href: t, pathname: r, search: o, hash: s } = new URL(n, e);
+  return { href: t, pathname: r, search: o, hash: s };
+}
+export {
+  a as blockers,
+  l as bypass,
+  u as evaluate,
+  i as locationOf
+};
+//# sourceMappingURL=registry.js.map

package/dist/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sources":["../src/registry.ts"],"sourcesContent":["import type { ShouldBlockFnArgs, ShouldBlockFnLocation } from \"./types\";\n\n/**\n * The blockers on the page, and the one evaluation every door shares.\n *\n * Module state on purpose: the root's listeners and `/next`'s `Link` and `useRouter` must consult\n * the same list, and the build writes one file per module so both doors import this one rather than\n * each inlining a copy. No DOM here — `platform.ts` is the half that touches `window`.\n */\n\nexport interface Blocker {\n  /** `true` blocks, `false` lets it through; a promise is a decision still being made. */\n  fn: (args: ShouldBlockFnArgs) => boolean | Promise<boolean>;\n  enableBeforeUnload: () => boolean;\n}\n\nexport const blockers: Blocker[] = [];\n\n/**\n * One-shot passes for a navigation this package is replaying after `proceed`, so the replay is not\n * blocked a second time. TanStack's `ignoreNextBeforeUnload` and `skipBlockerNextPop`, in the two\n * places a replay reaches here.\n */\nexport const bypass = { navigate: false, beforeunload: false };\n\n/**\n * Blockers in registration order, and the first that says `true` blocks.\n *\n * Synchronous for as long as every blocker answers synchronously, which is what lets a clean form\n * leave `Link` and `navigate` completely alone. A promise anywhere turns the rest of the walk into\n * one: the caller then has to cancel now and replay later, because both hooks it sits on demand a\n * synchronous `preventDefault()`.\n */\nexport function evaluate(args: ShouldBlockFnArgs): boolean | Promise<boolean> {\n  const from = (start: number): boolean | Promise<boolean> => {\n    const list = blockers.slice(start);\n    for (const [offset, blocker] of list.entries()) {\n      const verdict = blocker.fn(args);\n      if (verdict === true) return true;\n      if (verdict !== false) {\n        return Promise.resolve(verdict).then((block) => (block ? true : from(start + offset + 1)));\n      }\n    }\n    return false;\n  };\n  return from(0);\n}\n\nexport function locationOf(url: string | URL, base?: string): ShouldBlockFnLocation {\n  const { href, pathname, search, hash } = new URL(url, base);\n  return { href, pathname, search, hash };\n}\n"],"names":["blockers","bypass","evaluate","args","from","start","list","offset","blocker","verdict","block","locationOf","url","base","href","pathname","search","hash"],"mappings":"AAgBO,MAAMA,IAAsB,CAAA,GAOtBC,IAAS,EAAE,UAAU,IAAO,cAAc,GAAA;AAUhD,SAASC,EAASC,GAAqD;AAC5E,QAAMC,IAAO,CAACC,MAA8C;AAC1D,UAAMC,IAAON,EAAS,MAAMK,CAAK;AACjC,eAAW,CAACE,GAAQC,CAAO,KAAKF,EAAK,WAAW;AAC9C,YAAMG,IAAUD,EAAQ,GAAGL,CAAI;AAC/B,UAAIM,MAAY,GAAM,QAAO;AAC7B,UAAIA,MAAY;AACd,eAAO,QAAQ,QAAQA,CAAO,EAAE,KAAK,CAACC,MAAWA,IAAQ,KAAON,EAAKC,IAAQE,IAAS,CAAC,CAAE;AAAA,IAE7F;AACA,WAAO;AAAA,EACT;AACA,SAAOH,EAAK,CAAC;AACf;AAEO,SAASO,EAAWC,GAAmBC,GAAsC;AAClF,QAAM,EAAE,MAAAC,GAAM,UAAAC,GAAU,QAAAC,GAAQ,MAAAC,MAAS,IAAI,IAAIL,GAAKC,CAAI;AAC1D,SAAO,EAAE,MAAAC,GAAM,UAAAC,GAAU,QAAAC,GAAQ,MAAAC,EAAA;AACnC;"}

package/dist/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * TanStack Router's blocker vocabulary, name for name. The one shape that differs is the location:
+ * TanStack hands `{ routeId, fullPath, params }`, and Next matches routes on the server only, so
+ * what a client can honestly say about a destination is its URL.
+ */
+export type HistoryAction = "PUSH" | "REPLACE" | "BACK" | "FORWARD" | "GO";
+export interface ShouldBlockFnLocation {
+    href: string;
+    pathname: string;
+    search: string;
+    hash: string;
+}
+export interface ShouldBlockFnArgs {
+    current: ShouldBlockFnLocation;
+    next: ShouldBlockFnLocation;
+    action: HistoryAction;
+}
+export type ShouldBlockFn = (args: ShouldBlockFnArgs) => boolean | Promise<boolean>;
+export interface UseBlockerOpts {
+    shouldBlockFn: ShouldBlockFn;
+    /** Ask the browser's own dialog on reload, close and the URL bar. `true` by default. */
+    enableBeforeUnload?: boolean | (() => boolean);
+    disabled?: boolean;
+    withResolver?: boolean;
+}
+export type BlockerResolver = {
+    status: "blocked";
+    current: ShouldBlockFnLocation;
+    next: ShouldBlockFnLocation;
+    action: HistoryAction;
+    proceed: () => void;
+    reset: () => void;
+} | {
+    status: "idle";
+    current: undefined;
+    next: undefined;
+    action: undefined;
+    proceed: undefined;
+    reset: undefined;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;AAE3E,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,qBAAqB,CAAC;IAC/B,IAAI,EAAE,qBAAqB,CAAC;IAC5B,MAAM,EAAE,aAAa,CAAC;CACvB;AAED,MAAM,MAAM,aAAa,GAAG,CAAC,IAAI,EAAE,iBAAiB,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAEpF,MAAM,WAAW,cAAc;IAC7B,aAAa,EAAE,aAAa,CAAC;IAC7B,wFAAwF;IACxF,kBAAkB,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,CAAC;IAC/C,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,MAAM,eAAe,GACvB;IACE,MAAM,EAAE,SAAS,CAAC;IAClB,OAAO,EAAE,qBAAqB,CAAC;IAC/B,IAAI,EAAE,qBAAqB,CAAC;IAC5B,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,GACD;IACE,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,SAAS,CAAC;IACnB,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,SAAS,CAAC;IAClB,OAAO,EAAE,SAAS,CAAC;IACnB,KAAK,EAAE,SAAS,CAAC;CAClB,CAAC"}

package/dist/use-blocker.d.ts

@@ -0,0 +1,21 @@
+import { BlockerResolver, UseBlockerOpts } from './types';
+/**
+ * Blocks leaving the page while `shouldBlockFn` says so. TanStack Router's `useBlocker`, verbatim in
+ * its options and its resolver; `/docs/design/navigation` is what differs and why.
+ *
+ * With `withResolver`, a navigation `shouldBlockFn` blocks is held — `status: "blocked"` — until
+ * `proceed` lets it continue or `reset` stays. The dialog that asks is the product's.
+ *
+ * `enableBeforeUnload` is **not** derived from `shouldBlockFn`: the browser asks synchronously and
+ * `shouldBlockFn` may not answer that way. Left at its default, a page carrying this hook is asked
+ * about on every reload — which is why `disabled: !dirty` is the idiom, not `shouldBlockFn: () =>
+ * dirty` alone.
+ */
+export declare function useBlocker(opts: UseBlockerOpts & {
+    withResolver: true;
+}): BlockerResolver;
+export declare function useBlocker(opts: UseBlockerOpts & {
+    withResolver?: false;
+}): void;
+export declare function useBlocker(opts: UseBlockerOpts): BlockerResolver | void;
+//# sourceMappingURL=use-blocker.d.ts.map

package/dist/use-blocker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-blocker.d.ts","sourceRoot":"","sources":["../src/use-blocker.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAqB,cAAc,EAAE,MAAM,SAAS,CAAC;AAWlF;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG;IAAE,YAAY,EAAE,IAAI,CAAA;CAAE,GAAG,eAAe,CAAC;AAC3F,wBAAgB,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG;IAAE,YAAY,CAAC,EAAE,KAAK,CAAA;CAAE,GAAG,IAAI,CAAC;AAClF,wBAAgB,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,eAAe,GAAG,IAAI,CAAC"}

package/dist/use-blocker.js

@@ -0,0 +1,51 @@
+"use client";
+import { useState as k, useRef as p, useEffect as b } from "react";
+import { register as x } from "./platform.js";
+const d = {
+  status: "idle",
+  current: void 0,
+  next: void 0,
+  action: void 0,
+  proceed: void 0,
+  reset: void 0
+};
+function h({
+  shouldBlockFn: u,
+  enableBeforeUnload: c = !0,
+  disabled: f = !1,
+  withResolver: i = !1
+}) {
+  const [v, l] = k(d), o = p({ shouldBlockFn: u, enableBeforeUnload: c });
+  return o.current = { shouldBlockFn: u, enableBeforeUnload: c }, b(() => {
+    if (f) return;
+    let t;
+    const a = (r) => {
+      t == null || t(!0);
+      let e = () => {
+      };
+      const n = new Promise((s) => e = s);
+      return t = e, l({
+        status: "blocked",
+        ...r,
+        proceed: () => e(!1),
+        reset: () => e(!0)
+      }), n.then((s) => (t === e && (t = void 0, l(d)), s));
+    }, m = x({
+      fn: (r) => {
+        const e = o.current.shouldBlockFn(r);
+        return !i || e === !1 ? e : e === !0 ? a(r) : e.then((n) => n ? a(r) : !1);
+      },
+      enableBeforeUnload: () => {
+        const r = o.current.enableBeforeUnload;
+        return typeof r == "function" ? r() : r;
+      }
+    });
+    return () => {
+      m(), t == null || t(!0);
+    };
+  }, [f, i]), v;
+}
+export {
+  h as useBlocker
+};
+//# sourceMappingURL=use-blocker.js.map

package/dist/use-blocker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-blocker.js","sources":["../src/use-blocker.ts"],"sourcesContent":["\"use client\";\n\nimport { useEffect, useRef, useState } from \"react\";\nimport { register } from \"./platform\";\nimport type { BlockerResolver, ShouldBlockFnArgs, UseBlockerOpts } from \"./types\";\n\nconst IDLE: BlockerResolver = {\n  status: \"idle\",\n  current: undefined,\n  next: undefined,\n  action: undefined,\n  proceed: undefined,\n  reset: undefined,\n};\n\n/**\n * Blocks leaving the page while `shouldBlockFn` says so. TanStack Router's `useBlocker`, verbatim in\n * its options and its resolver; `/docs/design/navigation` is what differs and why.\n *\n * With `withResolver`, a navigation `shouldBlockFn` blocks is held — `status: \"blocked\"` — until\n * `proceed` lets it continue or `reset` stays. The dialog that asks is the product's.\n *\n * `enableBeforeUnload` is **not** derived from `shouldBlockFn`: the browser asks synchronously and\n * `shouldBlockFn` may not answer that way. Left at its default, a page carrying this hook is asked\n * about on every reload — which is why `disabled: !dirty` is the idiom, not `shouldBlockFn: () =>\n * dirty` alone.\n */\nexport function useBlocker(opts: UseBlockerOpts & { withResolver: true }): BlockerResolver;\nexport function useBlocker(opts: UseBlockerOpts & { withResolver?: false }): void;\nexport function useBlocker(opts: UseBlockerOpts): BlockerResolver | void;\nexport function useBlocker({\n  shouldBlockFn,\n  enableBeforeUnload = true,\n  disabled = false,\n  withResolver = false,\n}: UseBlockerOpts): BlockerResolver | void {\n  const [resolver, setResolver] = useState<BlockerResolver>(IDLE);\n\n  // The latest options, read at navigation time. Registering again whenever an inline function\n  // changed identity would move this blocker to the end of the order on every render.\n  const latest = useRef({ shouldBlockFn, enableBeforeUnload });\n  latest.current = { shouldBlockFn, enableBeforeUnload };\n\n  useEffect(() => {\n    if (disabled) return;\n    let pending: ((block: boolean) => void) | undefined;\n\n    const ask = (args: ShouldBlockFnArgs) => {\n      // A second navigation while the first is still being asked about: the first one stays.\n      pending?.(true);\n      let settle: (block: boolean) => void = () => {};\n      const asked = new Promise<boolean>((resolve) => (settle = resolve));\n      pending = settle;\n      setResolver({\n        status: \"blocked\",\n        ...args,\n        proceed: () => settle(false),\n        reset: () => settle(true),\n      });\n      return asked.then((block) => {\n        // Only the navigation still being asked about may put the resolver back to idle.\n        if (pending === settle) {\n          pending = undefined;\n          setResolver(IDLE);\n        }\n        return block;\n      });\n    };\n\n    const unregister = register({\n      fn: (args) => {\n        const verdict = latest.current.shouldBlockFn(args);\n        if (!withResolver || verdict === false) return verdict;\n        if (verdict === true) return ask(args);\n        return verdict.then((block) => (block ? ask(args) : false));\n      },\n      enableBeforeUnload: () => {\n        const enabled = latest.current.enableBeforeUnload;\n        return typeof enabled === \"function\" ? enabled() : enabled;\n      },\n    });\n\n    return () => {\n      unregister();\n      pending?.(true);\n    };\n  }, [disabled, withResolver]);\n\n  return resolver;\n}\n"],"names":[],"mappings":";;;AAMA;AAA8B;AACpB;AACC;AACH;AACE;AACC;AAEX;AAiBO;AAAoB;AACzB;AACqB;AACV;AAEb;AACE;AAKA;AAGE;AACA;AAEA;AAEE;AACA;AAA6C;AAC7C;AACA;AACY;AACF;AACL;AACwB;AACH;AASzB;AAGyB;AAExB;AACA;AAE0D;AAC5D;AAEE;AACA;AAAmD;AACrD;AAGF;AACE;AACU;AACZ;AAIJ;;;;"}

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@kanzo-tech/navigation",
+  "version": "0.11.0",
+  "description": "Kanzo's unsaved-changes guard — one useBlocker in TanStack Router's shape over the Navigation API and beforeunload, and a /next door for the App Router's Link and router. Sibling of @kanzo-tech/ui, not part of it: a router integration is product territory by /docs/philosophy, and nothing here draws.",
+  "type": "module",
+  "license": "MIT",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./next": {
+      "types": "./dist/next.d.ts",
+      "import": "./dist/next.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "//peers": "react is REQUIRED: the root is a hook. next is optional and lives behind `./next`, from 15.3 because that is the release `Link` gained `onNavigate` — the only cancellable moment Next gives a link. A host that is not Next installs this package alone and gets the browser half. Deliberately absent: tailwind-variants and @kanzo-tech/ui, because nothing here draws; the confirm dialog is the product's AlertDialog. That absence is also what keeps this package out of the appearance guards, whose corpus in packages/ui/src/guard-corpus.ts selects on that dependency.",
+  "peerDependencies": {
+    "next": ">=15.3",
+    "react": ">=19"
+  },
+  "peerDependenciesMeta": {
+    "next": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "jsdom": "^29.1.1",
+    "next": "^16.2.7",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "rollup-plugin-preserve-directives": "^0.4.0"
+  },
+  "//size-limit": "Set just above the first measurement, for the reason auth's note gives: a budget with 70% headroom detects nothing. The root barrel measured 1.06 kB — the hook, the registry and the two listeners — and `./next` 1.04 kB — the two adapters and the registry they share with the root; both budgets are 1.2 kB. `next` is ignored on the second because the consumer installs it and what is measured is our adapter over it. What these numbers watch for is a door reaching through another: the root learning a router, or `./next` pulling the hook and the listeners in behind `Link`. Either is a jump of the size of the other door, and a raise is a decision written here, never a quiet edit.",
+  "size-limit": [
+    {
+      "name": "root barrel (JS)",
+      "path": "dist/index.js",
+      "limit": "1.2 kB",
+      "ignore": [
+        "react",
+        "react-dom",
+        "react/jsx-runtime"
+      ]
+    },
+    {
+      "name": "next subpath (JS)",
+      "path": "dist/next.js",
+      "limit": "1.2 kB",
+      "ignore": [
+        "react",
+        "react-dom",
+        "react/jsx-runtime",
+        "next",
+        "next/link",
+        "next/navigation"
+      ]
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Kanzo-Tech/ui.git",
+    "directory": "packages/navigation"
+  },
+  "homepage": "https://kanzo-tech.github.io/ui",
+  "bugs": {
+    "url": "https://github.com/Kanzo-Tech/ui/issues"
+  },
+  "scripts": {
+    "build": "vite build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "size": "size-limit"
+  }
+}