@entifix/next-shell 0.1.0-0

package/dist/lib/workspace/workspace-shell.js

@@ -0,0 +1,206 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ConfirmDialog, Tab, TabStrip, TopBar, useT, useTranslateKey } from '@entifix/react-controls';
+import { usePathname, useRouter, useSearchParams } from 'next/navigation';
+import { useEffect, useState } from 'react';
+import { useDraftsState } from './drafts-state.js';
+import { useTabsState } from './tabs-state.js';
+/**
+ * The tab workspace: a strip of persisted tabs over the active tab's body — no
+ * sidebar or brand of its own. It is mounted inside a host shell (the
+ * back-office layout, say) that already supplies those, so nesting two
+ * sidebars never happens. The open set lives in {@link useTabsState}
+ * (IndexedDB); the URL's `?tab=` projects only the active tab, so a deep link
+ * opens or focuses exactly that tab and an unknown kind shows the fallback
+ * instead of crashing.
+ */ export function WorkspaceShell({ scope, registry, actions, fallback, emptyState }) {
+    const t = useT('shell');
+    // Tab captions are catalog keys carried in a registry, not authored copy.
+    const translate = useTranslateKey();
+    const searchParams = useSearchParams();
+    const router = useRouter();
+    const pathname = usePathname();
+    const urlTab = searchParams.get('tab');
+    const tabs = useTabsState((state)=>state.tabs);
+    const activeParam = useTabsState((state)=>state.activeParam);
+    const open = useTabsState((state)=>state.open);
+    const close = useTabsState((state)=>state.close);
+    const activate = useTabsState((state)=>state.activate);
+    const drafts = useDraftsState((state)=>state.drafts);
+    const clearDraft = useDraftsState((state)=>state.clearDraft);
+    // Load the persisted tab set and drafts once, on the client (hydration is
+    // skipped at creation so SSR never touches IndexedDB).
+    //
+    // Both URL effects below wait on this flag, because the read is async and
+    // lands *after* the first commit: opening the deep-linked tab before it
+    // resolves means the restored snapshot's `activeParam` overwrites the tab the
+    // URL asked for, and the write-back then projects that wrong tab into the
+    // address bar. The URL is the more specific instruction, so it is applied
+    // once the store has finished restoring rather than before.
+    const [hydrated, setHydrated] = useState(false);
+    useEffect(()=>{
+        // The scope is applied *before* the read, not after: the storage key is what
+        // decides whose tabs and drafts come back, so setting it late would restore
+        // the unscoped set first and only then start writing to the right key. Both
+        // stores are module singletons with `skipHydration`, and this is the only
+        // place that rehydrates them, so re-pointing them here is enough — no store
+        // factory or provider is needed to keep two accounts apart.
+        useTabsState.persist.setOptions({
+            name: `tabs:${scope}`
+        });
+        useDraftsState.persist.setOptions({
+            name: `drafts:${scope}`
+        });
+        void Promise.all([
+            useTabsState.persist.rehydrate(),
+            useDraftsState.persist.rehydrate()
+        ]).finally(()=>setHydrated(true));
+    }, [
+        scope
+    ]);
+    // The `?tab=` value the registry cannot resolve, if any — derived, so it is
+    // known on the very first render rather than an effect later. An
+    // unresolvable address used to be dropped on the floor: no tab, no error,
+    // and the write-back below then replaced it with the previously active tab,
+    // so even the URL stopped saying what was asked for. Here it answers with
+    // the fallback and the bad address stays in the bar, where it can be read.
+    //
+    // `dismissed` is the escape: a deliberate tab interaction is a newer
+    // instruction than the address that failed, and it holds the *value* rather
+    // than a flag so the next dead link is dead again.
+    const [dismissed, setDismissed] = useState(null);
+    const deadLink = urlTab && urlTab !== dismissed && !registry.resolve(urlTab, translate) ? urlTab : null;
+    // A tab is dirty while its address has an unsaved draft; closing one confirms.
+    //
+    // The confirmation is a rendered dialog, so the decision spans two commits
+    // rather than one blocking call: `handleClose` either closes outright or
+    // parks the address, and the dialog's own buttons finish it. `window.confirm`
+    // could not be styled, blocked the thread while it was up, and in Playwright
+    // had to be driven by a global `page.on('dialog')` handler registered before
+    // the click — which is why the workspace had no end-to-end test at all.
+    const [pendingClose, setPendingClose] = useState(null);
+    const commitClose = (param)=>{
+        // Unconditional: `clearDraft` returns the state unchanged when the address
+        // holds no draft, so the clean path costs a no-op rather than a branch.
+        clearDraft(param);
+        setDismissed(urlTab);
+        close(param);
+    };
+    const handleClose = (param)=>{
+        if (param in drafts) {
+            setPendingClose(param);
+            return;
+        }
+        commitClose(param);
+    };
+    const handleActivate = (param)=>{
+        setDismissed(urlTab);
+        activate(param);
+    };
+    // Deep link → open/focus the addressed tab (a dead one shows the fallback).
+    useEffect(()=>{
+        if (!hydrated || !urlTab) return;
+        const resolved = registry.resolve(urlTab, translate);
+        if (resolved) {
+            open({
+                param: resolved.param,
+                title: resolved.title
+            });
+        }
+    }, [
+        hydrated,
+        urlTab,
+        registry,
+        open,
+        translate
+    ]);
+    // Project the active tab back to the URL so it stays shareable.
+    //
+    // The active tab is read from the *committed* store rather than from this
+    // render's snapshot. Following a link to a second tab changes the URL one
+    // commit before the store catches up, so the snapshot still names the
+    // previously active tab — writing that back would undo the navigation, the
+    // effect above would re-open the URL's tab, and the two would trade the
+    // address bar back and forth forever (a visible flicker between, say, brands
+    // and categories). The effect above runs first in the same commit, so by the
+    // time this one reads the store the URL's tab is already active.
+    // That ordering is also what makes the `hydrated` gate work: when the flag
+    // flips, the effect above has already re-applied the URL's tab over the
+    // restored snapshot, so there is nothing here to write back.
+    //
+    // A dead deep link suspends it: overwriting the address the visitor typed
+    // with an unrelated tab is what made the failure invisible in the first place.
+    useEffect(()=>{
+        if (!hydrated || deadLink) return;
+        const active = useTabsState.getState().activeParam;
+        if (active && active !== urlTab) {
+            router.replace(`${pathname}?tab=${encodeURIComponent(active)}`);
+        }
+    }, [
+        hydrated,
+        deadLink,
+        activeParam,
+        urlTab,
+        pathname,
+        router
+    ]);
+    const copyDeepLink = (param)=>{
+        void navigator.clipboard.writeText(`${window.location.origin}${pathname}?tab=${encodeURIComponent(param)}`);
+    };
+    const activeResolved = activeParam ? registry.resolve(activeParam, translate) : null;
+    const body = deadLink ? fallback : activeResolved ? activeResolved.render() : emptyState;
+    return /*#__PURE__*/ _jsxs("div", {
+        className: "min-w-0 flex flex-1 flex-col",
+        children: [
+            /*#__PURE__*/ _jsx(TopBar, {
+                children: /*#__PURE__*/ _jsxs(TopBar.Actions, {
+                    children: [
+                        activeParam && /*#__PURE__*/ _jsx("button", {
+                            type: "button",
+                            onClick: ()=>copyDeepLink(activeParam),
+                            className: "rounded-md px-2xs py-3xs text-step-sm text-content-muted focus-ring transition hover:bg-surface hover:text-content",
+                            children: t('workspace.copyLink')
+                        }),
+                        actions
+                    ]
+                })
+            }),
+            /*#__PURE__*/ _jsx(TabStrip, {
+                children: tabs.map((tab)=>{
+                    var _ref;
+                    var _registry_resolve;
+                    return /*#__PURE__*/ _jsx(Tab, {
+                        // Re-derived from the registry rather than read back from the
+                        // store: the persisted title is whatever locale it was opened
+                        // in, so a locale switch would leave stale captions behind.
+                        label: (_ref = (_registry_resolve = registry.resolve(tab.param, translate)) == null ? void 0 : _registry_resolve.title) != null ? _ref : tab.title,
+                        // Nothing is selected while the fallback is up: a highlighted
+                        // tab beside a body that is not its own reads as a render bug.
+                        active: !deadLink && tab.param === activeParam,
+                        state: tab.param in drafts ? 'dirty' : 'idle',
+                        onSelect: ()=>handleActivate(tab.param),
+                        onClose: ()=>handleClose(tab.param)
+                    }, tab.param);
+                })
+            }),
+            /*#__PURE__*/ _jsx("div", {
+                className: "min-w-0 flex-1 p-m",
+                children: body
+            }),
+            pendingClose && /*#__PURE__*/ _jsx(ConfirmDialog, {
+                open: true,
+                tone: "destructive",
+                title: t('workspace.discardTitle'),
+                message: t('workspace.discard'),
+                confirmLabel: t('workspace.discardConfirm'),
+                onCancel: ()=>setPendingClose(null),
+                onConfirm: ()=>{
+                    commitClose(pendingClose);
+                    setPendingClose(null);
+                }
+            })
+        ]
+    });
+}
+
+//# sourceMappingURL=workspace-shell.js.map

package/dist/lib/workspace/workspace-shell.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/workspace/workspace-shell.tsx"],"sourcesContent":["'use client';\n\nimport {\n  ConfirmDialog,\n  Tab,\n  TabStrip,\n  TopBar,\n  useT,\n  useTranslateKey,\n} from '@entifix/react-controls';\nimport { usePathname, useRouter, useSearchParams } from 'next/navigation';\nimport { type ReactNode, useEffect, useState } from 'react';\n\nimport { useDraftsState } from './drafts-state.js';\nimport type { TabRegistry } from './tab-kind.js';\nimport { useTabsState } from './tabs-state.js';\n\nexport interface WorkspaceShellProps {\n  /**\n   * Who this workspace belongs to — `workspaceScopeKey({ userId,\n   * organizationId })`, resolved on the server from the session.\n   *\n   * Required, deliberately: IndexedDB is a property of the browser profile, so a\n   * host that forgets to pass one hands the next account to sign in on that\n   * machine the previous account's open tabs and half-finished edits. A default\n   * would make that the quiet outcome of doing nothing.\n   */\n  scope: string;\n  /** Resolves `?tab=` values to renderable tabs. */\n  registry: TabRegistry;\n  /** Right-aligned actions above the tab strip (search, the user menu). */\n  actions?: ReactNode;\n  /** Body when `?tab=` names something the registry cannot resolve. */\n  fallback?: ReactNode;\n  /** Body when no tab is open. */\n  emptyState?: ReactNode;\n}\n\n/**\n * The tab workspace: a strip of persisted tabs over the active tab's body — no\n * sidebar or brand of its own. It is mounted inside a host shell (the\n * back-office layout, say) that already supplies those, so nesting two\n * sidebars never happens. The open set lives in {@link useTabsState}\n * (IndexedDB); the URL's `?tab=` projects only the active tab, so a deep link\n * opens or focuses exactly that tab and an unknown kind shows the fallback\n * instead of crashing.\n */\nexport function WorkspaceShell({\n  scope,\n  registry,\n  actions,\n  fallback,\n  emptyState,\n}: WorkspaceShellProps) {\n  const t = useT('shell');\n  // Tab captions are catalog keys carried in a registry, not authored copy.\n  const translate = useTranslateKey();\n  const searchParams = useSearchParams();\n  const router = useRouter();\n  const pathname = usePathname();\n  const urlTab = searchParams.get('tab');\n\n  const tabs = useTabsState(state => state.tabs);\n  const activeParam = useTabsState(state => state.activeParam);\n  const open = useTabsState(state => state.open);\n  const close = useTabsState(state => state.close);\n  const activate = useTabsState(state => state.activate);\n\n  const drafts = useDraftsState(state => state.drafts);\n  const clearDraft = useDraftsState(state => state.clearDraft);\n\n  // Load the persisted tab set and drafts once, on the client (hydration is\n  // skipped at creation so SSR never touches IndexedDB).\n  //\n  // Both URL effects below wait on this flag, because the read is async and\n  // lands *after* the first commit: opening the deep-linked tab before it\n  // resolves means the restored snapshot's `activeParam` overwrites the tab the\n  // URL asked for, and the write-back then projects that wrong tab into the\n  // address bar. The URL is the more specific instruction, so it is applied\n  // once the store has finished restoring rather than before.\n  const [hydrated, setHydrated] = useState(false);\n  useEffect(() => {\n    // The scope is applied *before* the read, not after: the storage key is what\n    // decides whose tabs and drafts come back, so setting it late would restore\n    // the unscoped set first and only then start writing to the right key. Both\n    // stores are module singletons with `skipHydration`, and this is the only\n    // place that rehydrates them, so re-pointing them here is enough — no store\n    // factory or provider is needed to keep two accounts apart.\n    useTabsState.persist.setOptions({ name: `tabs:${scope}` });\n    useDraftsState.persist.setOptions({ name: `drafts:${scope}` });\n    void Promise.all([\n      useTabsState.persist.rehydrate(),\n      useDraftsState.persist.rehydrate(),\n    ]).finally(() => setHydrated(true));\n  }, [scope]);\n\n  // The `?tab=` value the registry cannot resolve, if any — derived, so it is\n  // known on the very first render rather than an effect later. An\n  // unresolvable address used to be dropped on the floor: no tab, no error,\n  // and the write-back below then replaced it with the previously active tab,\n  // so even the URL stopped saying what was asked for. Here it answers with\n  // the fallback and the bad address stays in the bar, where it can be read.\n  //\n  // `dismissed` is the escape: a deliberate tab interaction is a newer\n  // instruction than the address that failed, and it holds the *value* rather\n  // than a flag so the next dead link is dead again.\n  const [dismissed, setDismissed] = useState<string | null>(null);\n  const deadLink =\n    urlTab && urlTab !== dismissed && !registry.resolve(urlTab, translate)\n      ? urlTab\n      : null;\n\n  // A tab is dirty while its address has an unsaved draft; closing one confirms.\n  //\n  // The confirmation is a rendered dialog, so the decision spans two commits\n  // rather than one blocking call: `handleClose` either closes outright or\n  // parks the address, and the dialog's own buttons finish it. `window.confirm`\n  // could not be styled, blocked the thread while it was up, and in Playwright\n  // had to be driven by a global `page.on('dialog')` handler registered before\n  // the click — which is why the workspace had no end-to-end test at all.\n  const [pendingClose, setPendingClose] = useState<string | null>(null);\n\n  const commitClose = (param: string) => {\n    // Unconditional: `clearDraft` returns the state unchanged when the address\n    // holds no draft, so the clean path costs a no-op rather than a branch.\n    clearDraft(param);\n    setDismissed(urlTab);\n    close(param);\n  };\n\n  const handleClose = (param: string) => {\n    if (param in drafts) {\n      setPendingClose(param);\n      return;\n    }\n    commitClose(param);\n  };\n\n  const handleActivate = (param: string) => {\n    setDismissed(urlTab);\n    activate(param);\n  };\n\n  // Deep link → open/focus the addressed tab (a dead one shows the fallback).\n  useEffect(() => {\n    if (!hydrated || !urlTab) return;\n    const resolved = registry.resolve(urlTab, translate);\n    if (resolved) {\n      open({ param: resolved.param, title: resolved.title });\n    }\n  }, [hydrated, urlTab, registry, open, translate]);\n\n  // Project the active tab back to the URL so it stays shareable.\n  //\n  // The active tab is read from the *committed* store rather than from this\n  // render's snapshot. Following a link to a second tab changes the URL one\n  // commit before the store catches up, so the snapshot still names the\n  // previously active tab — writing that back would undo the navigation, the\n  // effect above would re-open the URL's tab, and the two would trade the\n  // address bar back and forth forever (a visible flicker between, say, brands\n  // and categories). The effect above runs first in the same commit, so by the\n  // time this one reads the store the URL's tab is already active.\n  // That ordering is also what makes the `hydrated` gate work: when the flag\n  // flips, the effect above has already re-applied the URL's tab over the\n  // restored snapshot, so there is nothing here to write back.\n  //\n  // A dead deep link suspends it: overwriting the address the visitor typed\n  // with an unrelated tab is what made the failure invisible in the first place.\n  useEffect(() => {\n    if (!hydrated || deadLink) return;\n    const active = useTabsState.getState().activeParam;\n    if (active && active !== urlTab) {\n      router.replace(`${pathname}?tab=${encodeURIComponent(active)}`);\n    }\n  }, [hydrated, deadLink, activeParam, urlTab, pathname, router]);\n\n  const copyDeepLink = (param: string) => {\n    void navigator.clipboard.writeText(\n      `${window.location.origin}${pathname}?tab=${encodeURIComponent(param)}`,\n    );\n  };\n\n  const activeResolved = activeParam\n    ? registry.resolve(activeParam, translate)\n    : null;\n  const body = deadLink\n    ? fallback\n    : activeResolved\n      ? activeResolved.render()\n      : emptyState;\n\n  return (\n    <div className=\"min-w-0 flex flex-1 flex-col\">\n      <TopBar>\n        <TopBar.Actions>\n          {activeParam && (\n            <button\n              type=\"button\"\n              onClick={() => copyDeepLink(activeParam)}\n              className=\"rounded-md px-2xs py-3xs text-step-sm text-content-muted focus-ring transition hover:bg-surface hover:text-content\"\n            >\n              {t('workspace.copyLink')}\n            </button>\n          )}\n          {actions}\n        </TopBar.Actions>\n      </TopBar>\n\n      <TabStrip>\n        {tabs.map(tab => (\n          <Tab\n            key={tab.param}\n            // Re-derived from the registry rather than read back from the\n            // store: the persisted title is whatever locale it was opened\n            // in, so a locale switch would leave stale captions behind.\n            label={registry.resolve(tab.param, translate)?.title ?? tab.title}\n            // Nothing is selected while the fallback is up: a highlighted\n            // tab beside a body that is not its own reads as a render bug.\n            active={!deadLink && tab.param === activeParam}\n            state={tab.param in drafts ? 'dirty' : 'idle'}\n            onSelect={() => handleActivate(tab.param)}\n            onClose={() => handleClose(tab.param)}\n          />\n        ))}\n      </TabStrip>\n\n      <div className=\"min-w-0 flex-1 p-m\">{body}</div>\n\n      {pendingClose && (\n        <ConfirmDialog\n          open\n          tone=\"destructive\"\n          title={t('workspace.discardTitle')}\n          message={t('workspace.discard')}\n          confirmLabel={t('workspace.discardConfirm')}\n          onCancel={() => setPendingClose(null)}\n          onConfirm={() => {\n            commitClose(pendingClose);\n            setPendingClose(null);\n          }}\n        />\n      )}\n    </div>\n  );\n}\n"],"names":["ConfirmDialog","Tab","TabStrip","TopBar","useT","useTranslateKey","usePathname","useRouter","useSearchParams","useEffect","useState","useDraftsState","useTabsState","WorkspaceShell","scope","registry","actions","fallback","emptyState","t","translate","searchParams","router","pathname","urlTab","get","tabs","state","activeParam","open","close","activate","drafts","clearDraft","hydrated","setHydrated","persist","setOptions","name","Promise","all","rehydrate","finally","dismissed","setDismissed","deadLink","resolve","pendingClose","setPendingClose","commitClose","param","handleClose","handleActivate","resolved","title","active","getState","replace","encodeURIComponent","copyDeepLink","navigator","clipboard","writeText","window","location","origin","activeResolved","body","render","div","className","Actions","button","type","onClick","map","tab","label","onSelect","onClose","tone","message","confirmLabel","onCancel","onConfirm"],"mappings":"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"}

package/dist/server.d.ts

@@ -0,0 +1,13 @@
+export * from './lib/health/health-routes.js';
+export * from './lib/config/config-route.js';
+export * from './lib/config/service-token.js';
+export * from './lib/config/service-proxy-route.js';
+export * from './lib/session/cookies.js';
+export * from './lib/session/refresh-route.js';
+export * from './lib/crud/slug.js';
+export * from './lib/search/record-search-route.js';
+export * from './lib/search/record-search-source.js';
+export * from './lib/session/bearer.js';
+export * from './lib/session/account-links.js';
+export * from './lib/session/device.js';
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAWA,cAAc,+BAA+B,CAAC;AAG9C,cAAc,8BAA8B,CAAC;AAM7C,cAAc,+BAA+B,CAAC;AAG9C,cAAc,qCAAqC,CAAC;AAGpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC;AAK/C,cAAc,oBAAoB,CAAC;AAInC,cAAc,qCAAqC,CAAC;AACpD,cAAc,sCAAsC,CAAC;AAKrD,cAAc,yBAAyB,CAAC;AAIxC,cAAc,gCAAgC,CAAC;AAG/C,cAAc,yBAAyB,CAAC"}

package/dist/server.js

@@ -0,0 +1,41 @@
+// Server-only surface, published as `@entifix/next-shell/server`.
+//
+// It stays a separate entry so route handlers and cookie helpers are never
+// reached through the client surface: stamped as client modules they would
+// become client references and their `next/server` imports would fail. The
+// library compiles per-file, so each module keeps its own `"use client"` (or
+// keeps none, as here) instead of inheriting a bundle-wide banner.
+// React server components
+// Probe route handlers (liveness/readiness) shared by every Next app.
+export * from './lib/health/health-routes.js';
+// The `GET /api/config` handler + the same-origin domain rewrite it applies.
+export * from './lib/config/config-route.js';
+// The shared fleet token, and the header config-service reads it from. Exported
+// because a server component that reads config-service directly — rather than
+// through its own app's `/api/config` route — has to carry it itself. It never
+// reaches the browser: this is the server entry.
+export * from './lib/config/service-token.js';
+// The same-origin proxy each host mounts per backend it talks to.
+export * from './lib/config/service-proxy-route.js';
+// Session cookies + the shared refresh route handler
+export * from './lib/session/cookies.js';
+export * from './lib/session/refresh-route.js';
+// The `[slug]` value that means "create". A pure constant, exported from both
+// entries because both need it: the generated pages read it in the browser, and
+// a shell's palette commands compose the create route with it on the server.
+export * from './lib/crud/slug.js';
+// The cross-domain record search: the aggregating route, and the declarations a
+// host fans out over (ADR 0040).
+export * from './lib/search/record-search-route.js';
+export * from './lib/search/record-search-source.js';
+// The access cookie, read once and forwarded as a bearer. Three server surfaces
+// carry it the same way — the per-backend proxy, the auth shell's hand-written
+// handlers, and the record search fan-out — and none of them grants anything.
+export * from './lib/session/bearer.js';
+// Account-link builders. Pure functions, but server layouts call them directly,
+// and anything exported from the client entry becomes a client function.
+export * from './lib/session/account-links.js';
+// Device identity — read from the request, written onto the response.
+export * from './lib/session/device.js';
+
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/server.ts"],"sourcesContent":["// Server-only surface, published as `@entifix/next-shell/server`.\n//\n// It stays a separate entry so route handlers and cookie helpers are never\n// reached through the client surface: stamped as client modules they would\n// become client references and their `next/server` imports would fail. The\n// library compiles per-file, so each module keeps its own `\"use client\"` (or\n// keeps none, as here) instead of inheriting a bundle-wide banner.\n\n// React server components\n\n// Probe route handlers (liveness/readiness) shared by every Next app.\nexport * from './lib/health/health-routes.js';\n\n// The `GET /api/config` handler + the same-origin domain rewrite it applies.\nexport * from './lib/config/config-route.js';\n\n// The shared fleet token, and the header config-service reads it from. Exported\n// because a server component that reads config-service directly — rather than\n// through its own app's `/api/config` route — has to carry it itself. It never\n// reaches the browser: this is the server entry.\nexport * from './lib/config/service-token.js';\n\n// The same-origin proxy each host mounts per backend it talks to.\nexport * from './lib/config/service-proxy-route.js';\n\n// Session cookies + the shared refresh route handler\nexport * from './lib/session/cookies.js';\nexport * from './lib/session/refresh-route.js';\n\n// The `[slug]` value that means \"create\". A pure constant, exported from both\n// entries because both need it: the generated pages read it in the browser, and\n// a shell's palette commands compose the create route with it on the server.\nexport * from './lib/crud/slug.js';\n\n// The cross-domain record search: the aggregating route, and the declarations a\n// host fans out over (ADR 0040).\nexport * from './lib/search/record-search-route.js';\nexport * from './lib/search/record-search-source.js';\n\n// The access cookie, read once and forwarded as a bearer. Three server surfaces\n// carry it the same way — the per-backend proxy, the auth shell's hand-written\n// handlers, and the record search fan-out — and none of them grants anything.\nexport * from './lib/session/bearer.js';\n\n// Account-link builders. Pure functions, but server layouts call them directly,\n// and anything exported from the client entry becomes a client function.\nexport * from './lib/session/account-links.js';\n\n// Device identity — read from the request, written onto the response.\nexport * from './lib/session/device.js';\n"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,EAAE;AACF,2EAA2E;AAC3E,2EAA2E;AAC3E,2EAA2E;AAC3E,6EAA6E;AAC7E,mEAAmE;AAEnE,0BAA0B;AAE1B,sEAAsE;AACtE,cAAc,gCAAgC;AAE9C,6EAA6E;AAC7E,cAAc,+BAA+B;AAE7C,gFAAgF;AAChF,8EAA8E;AAC9E,+EAA+E;AAC/E,iDAAiD;AACjD,cAAc,gCAAgC;AAE9C,kEAAkE;AAClE,cAAc,sCAAsC;AAEpD,qDAAqD;AACrD,cAAc,2BAA2B;AACzC,cAAc,iCAAiC;AAE/C,8EAA8E;AAC9E,gFAAgF;AAChF,6EAA6E;AAC7E,cAAc,qBAAqB;AAEnC,gFAAgF;AAChF,iCAAiC;AACjC,cAAc,sCAAsC;AACpD,cAAc,uCAAuC;AAErD,gFAAgF;AAChF,+EAA+E;AAC/E,8EAA8E;AAC9E,cAAc,0BAA0B;AAExC,gFAAgF;AAChF,yEAAyE;AACzE,cAAc,iCAAiC;AAE/C,sEAAsE;AACtE,cAAc,0BAA0B"}

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@entifix/next-shell",
+  "nx": {
+    "tags": [
+      "layer:shell",
+      "scope:shared",
+      "shell:base",
+      "tier:4"
+    ],
+    "sourceRoot": "packages/next/shell/src",
+    "targets": {
+      "build": {
+        "executor": "@nx/js:swc",
+        "outputs": [
+          "{options.outputPath}"
+        ],
+        "options": {
+          "outputPath": "packages/next/shell/dist",
+          "main": "packages/next/shell/src/index.ts",
+          "tsConfig": "packages/next/shell/tsconfig.lib.json",
+          "skipTypeCheck": true,
+          "stripLeadingPaths": true
+        }
+      }
+    }
+  },
+  "version": "0.1.0-0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/r10c-technologies/entifix.git",
+    "directory": "packages/next/shell"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@entifix/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./server": {
+      "@entifix/source": "./src/server.ts",
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js",
+      "default": "./dist/server.js"
+    }
+  },
+  "devDependencies": {
+    "@tanstack/react-query": "^5.101.4",
+    "effect": "3.22.1",
+    "i18next": "26.3.6",
+    "next": "16.2.10",
+    "react": "19.2.8",
+    "react-dom": "19.2.8",
+    "zustand": "^5.0.15",
+    "@entifix/testing-unit": "0.1.0-0"
+  },
+  "dependencies": {
+    "idb": "^8.0.3",
+    "@entifix/authz": "0.1.0-0",
+    "@entifix/business": "0.1.0-0",
+    "@entifix/transactions": "0.1.0-0",
+    "@entifix/i18n": "0.1.0-0",
+    "@entifix/react-integration": "0.1.0-0",
+    "@entifix/react-controls": "0.1.0-0",
+    "@entifix/core": "0.1.0-0"
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "@tanstack/react-query": ">=5.101 <6",
+    "effect": ">=3.22 <4",
+    "i18next": ">=26 <27",
+    "next": ">=16 <17",
+    "react": ">=19 <20",
+    "react-dom": ">=19 <20",
+    "zustand": ">=5 <6"
+  },
+  "peerDependenciesMeta": {
+    "i18next": {
+      "optional": true
+    }
+  }
+}