@entifix/next-shell 0.1.0-0

package/dist/lib/workspace/tab-kind.js

@@ -0,0 +1,47 @@
+import { _ as _class_private_field_loose_base } from "@swc/helpers/_/_class_private_field_loose_base";
+import { _ as _class_private_field_loose_key } from "@swc/helpers/_/_class_private_field_loose_key";
+/** Split a `?tab=` value into its kind and payload halves. */ export function splitParam(param) {
+    const separator = param.indexOf(':');
+    return separator === -1 ? {
+        kind: param,
+        payload: ''
+    } : {
+        kind: param.slice(0, separator),
+        payload: param.slice(separator + 1)
+    };
+}
+var _kinds = /*#__PURE__*/ _class_private_field_loose_key("_kinds");
+/**
+ * The registry of tab kinds. `resolve` turns a `?tab=` value into a renderable
+ * tab, or `null` when the kind is unknown or the payload is invalid — the
+ * caller shows a fallback rather than crashing the workspace.
+ */ export class TabRegistry {
+    register(kind) {
+        _class_private_field_loose_base(this, _kinds)[_kinds].set(kind.kind, kind);
+        return this;
+    }
+    has(kind) {
+        return _class_private_field_loose_base(this, _kinds)[_kinds].has(kind);
+    }
+    resolve(param, translate) {
+        const { kind: kindName, payload } = splitParam(param);
+        const kind = _class_private_field_loose_base(this, _kinds)[_kinds].get(kindName);
+        if (!kind) return null;
+        const addr = kind.match(payload);
+        if (addr === null) return null;
+        return {
+            param: `${kind.kind}:${kind.toParam(addr)}`,
+            title: kind.title(addr, translate),
+            render: ()=>kind.render(addr)
+        };
+    }
+    constructor(){
+        Object.defineProperty(this, _kinds, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_loose_base(this, _kinds)[_kinds] = new Map();
+    }
+}
+
+//# sourceMappingURL=tab-kind.js.map

package/dist/lib/workspace/tab-kind.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/workspace/tab-kind.ts"],"sourcesContent":["import type { ReactNode } from 'react';\n\n/** Resolves a catalog key. The widened form: a tab title is data, not authored copy. */\nexport type TabTranslate = (\n  key: string,\n  params?: Record<string, unknown>,\n) => string;\n\n/**\n * One kind of tab (a catalog, an entity editor, later an operation or wizard).\n * A page is addressed by the `?tab=` value `\"<kind>:<payload>\"`; the kind owns\n * the payload half — parsing it to an address, serializing it back, and\n * rendering it. Registering a kind is the only change adding a new tab type\n * needs; the router and store never change.\n */\nexport interface TabKind<TAddr = unknown> {\n  /** The leading segment of the `?tab=` value, e.g. `catalog`, `entity`. */\n  kind: string;\n  /** Parse the part after `<kind>:` into an address, or `null` if invalid. */\n  match(payload: string): TAddr | null;\n  /** Serialize an address back to the payload (without the `<kind>:` prefix). */\n  toParam(addr: TAddr): string;\n  /**\n   * The tab caption. Handed a translate function rather than reaching for a\n   * hook: kinds are registered at module scope, outside any React tree.\n   */\n  title(addr: TAddr, translate: TabTranslate): string;\n  render(addr: TAddr): ReactNode;\n}\n\n/** A resolved tab: everything the strip and body need, addressed by `param`. */\nexport interface ResolvedTab {\n  /** The canonical `?tab=` value — the tab's identity and deep link. */\n  param: string;\n  title: string;\n  render: () => ReactNode;\n}\n\n/** Split a `?tab=` value into its kind and payload halves. */\nexport function splitParam(param: string): { kind: string; payload: string } {\n  const separator = param.indexOf(':');\n  return separator === -1\n    ? { kind: param, payload: '' }\n    : { kind: param.slice(0, separator), payload: param.slice(separator + 1) };\n}\n\n/**\n * The registry of tab kinds. `resolve` turns a `?tab=` value into a renderable\n * tab, or `null` when the kind is unknown or the payload is invalid — the\n * caller shows a fallback rather than crashing the workspace.\n */\nexport class TabRegistry {\n  readonly #kinds = new Map<string, TabKind<unknown>>();\n\n  register<TAddr>(kind: TabKind<TAddr>): this {\n    this.#kinds.set(kind.kind, kind as TabKind<unknown>);\n    return this;\n  }\n\n  has(kind: string): boolean {\n    return this.#kinds.has(kind);\n  }\n\n  resolve(param: string, translate: TabTranslate): ResolvedTab | null {\n    const { kind: kindName, payload } = splitParam(param);\n    const kind = this.#kinds.get(kindName);\n    if (!kind) return null;\n\n    const addr = kind.match(payload);\n    if (addr === null) return null;\n\n    return {\n      param: `${kind.kind}:${kind.toParam(addr)}`,\n      title: kind.title(addr, translate),\n      render: () => kind.render(addr),\n    };\n  }\n}\n"],"names":["splitParam","param","separator","indexOf","kind","payload","slice","TabRegistry","register","set","has","resolve","translate","kindName","get","addr","match","toParam","title","render","Map"],"mappings":";;AAsCA,4DAA4D,GAC5D,OAAO,SAASA,WAAWC,KAAa;IACtC,MAAMC,YAAYD,MAAME,OAAO,CAAC;IAChC,OAAOD,cAAc,CAAC,IAClB;QAAEE,MAAMH;QAAOI,SAAS;IAAG,IAC3B;QAAED,MAAMH,MAAMK,KAAK,CAAC,GAAGJ;QAAYG,SAASJ,MAAMK,KAAK,CAACJ,YAAY;IAAG;AAC7E;IAQW;AANX;;;;CAIC,GACD,OAAO,MAAMK;IAGXC,SAAgBJ,IAAoB,EAAQ;QAC1C,gCAAA,IAAI,EAAC,QAAA,QAAOK,GAAG,CAACL,KAAKA,IAAI,EAAEA;QAC3B,OAAO,IAAI;IACb;IAEAM,IAAIN,IAAY,EAAW;QACzB,OAAO,gCAAA,IAAI,EAAC,QAAA,QAAOM,GAAG,CAACN;IACzB;IAEAO,QAAQV,KAAa,EAAEW,SAAuB,EAAsB;QAClE,MAAM,EAAER,MAAMS,QAAQ,EAAER,OAAO,EAAE,GAAGL,WAAWC;QAC/C,MAAMG,OAAO,gCAAA,IAAI,EAAC,QAAA,QAAOU,GAAG,CAACD;QAC7B,IAAI,CAACT,MAAM,OAAO;QAElB,MAAMW,OAAOX,KAAKY,KAAK,CAACX;QACxB,IAAIU,SAAS,MAAM,OAAO;QAE1B,OAAO;YACLd,OAAO,GAAGG,KAAKA,IAAI,CAAC,CAAC,EAAEA,KAAKa,OAAO,CAACF,OAAO;YAC3CG,OAAOd,KAAKc,KAAK,CAACH,MAAMH;YACxBO,QAAQ,IAAMf,KAAKe,MAAM,CAACJ;QAC5B;IACF;;QAxBA,4BAAS;;mBAAT,KAAA;;8CAAS,QAAA,UAAS,IAAIK;;AAyBxB"}

package/dist/lib/workspace/tab-state.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A single open tab. `param` is its `?tab=` value — both the deep-link address
+ * and the tab's identity, so opening the same address twice focuses the one
+ * that is already open rather than duplicating it.
+ */
+export interface TabRecord {
+    param: string;
+    title: string;
+}
+export interface TabsSnapshot {
+    tabs: TabRecord[];
+    activeParam: string | null;
+}
+export declare const emptyTabs: TabsSnapshot;
+/** Upper bound on open tabs before the oldest inactive one is evicted. */
+export declare const MAX_TABS = 12;
+/**
+ * Trim the set to {@link MAX_TABS} by evicting the oldest tabs first, never the
+ * active one. Evicting a tab does not lose its work — any draft survives in
+ * IndexedDB and is restored when the tab is reopened.
+ */
+export declare function capTabs(state: TabsSnapshot): TabsSnapshot;
+/**
+ * Open a tab, or focus and re-title it if its address is already open. The
+ * opened/focused tab becomes active; the set is capped at {@link MAX_TABS}.
+ */
+export declare function openOrFocus(state: TabsSnapshot, tab: TabRecord): TabsSnapshot;
+/**
+ * Close a tab. If it was active, focus its neighbour (the tab that slides into
+ * its place, else the one before it, else nothing). Closing an unknown tab is a
+ * no-op.
+ */
+export declare function closeTab(state: TabsSnapshot, param: string): TabsSnapshot;
+/** Focus an open tab; focusing an unknown one is a no-op. */
+export declare function setActive(state: TabsSnapshot, param: string): TabsSnapshot;
+//# sourceMappingURL=tab-state.d.ts.map

package/dist/lib/workspace/tab-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab-state.d.ts","sourceRoot":"","sources":["../../../src/lib/workspace/tab-state.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,eAAO,MAAM,SAAS,EAAE,YAA8C,CAAC;AAEvE,0EAA0E;AAC1E,eAAO,MAAM,QAAQ,KAAK,CAAC;AAE3B;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,CAYzD;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,EAAE,SAAS,GAAG,YAAY,CAiB7E;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAWzE;AAED,6DAA6D;AAC7D,wBAAgB,SAAS,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAG1E"}

package/dist/lib/workspace/tab-state.js

@@ -0,0 +1,81 @@
+/**
+ * A single open tab. `param` is its `?tab=` value — both the deep-link address
+ * and the tab's identity, so opening the same address twice focuses the one
+ * that is already open rather than duplicating it.
+ */ import { _ as _extends } from "@swc/helpers/_/_extends";
+export const emptyTabs = {
+    tabs: [],
+    activeParam: null
+};
+/** Upper bound on open tabs before the oldest inactive one is evicted. */ export const MAX_TABS = 12;
+/**
+ * Trim the set to {@link MAX_TABS} by evicting the oldest tabs first, never the
+ * active one. Evicting a tab does not lose its work — any draft survives in
+ * IndexedDB and is restored when the tab is reopened.
+ */ export function capTabs(state) {
+    let overflow = state.tabs.length - MAX_TABS;
+    if (overflow <= 0) return state;
+    const tabs = state.tabs.filter((open)=>{
+        if (overflow > 0 && open.param !== state.activeParam) {
+            overflow -= 1;
+            return false;
+        }
+        return true;
+    });
+    return _extends({}, state, {
+        tabs
+    });
+}
+/**
+ * Open a tab, or focus and re-title it if its address is already open. The
+ * opened/focused tab becomes active; the set is capped at {@link MAX_TABS}.
+ */ export function openOrFocus(state, tab) {
+    const existing = state.tabs.find((open)=>open.param === tab.param);
+    // Re-opening the tab that is already open and already active changes nothing;
+    // returning the same snapshot keeps subscribers from re-rendering on every
+    // URL⇄store sync, which is what turned a settled workspace into a churn of
+    // new tab arrays.
+    if ((existing == null ? void 0 : existing.title) === tab.title && state.activeParam === tab.param) {
+        return state;
+    }
+    const exists = existing !== undefined;
+    const tabs = exists ? state.tabs.map((open)=>open.param === tab.param ? _extends({}, open, {
+            title: tab.title
+        }) : open) : [
+        ...state.tabs,
+        tab
+    ];
+    return capTabs({
+        tabs,
+        activeParam: tab.param
+    });
+}
+/**
+ * Close a tab. If it was active, focus its neighbour (the tab that slides into
+ * its place, else the one before it, else nothing). Closing an unknown tab is a
+ * no-op.
+ */ export function closeTab(state, param) {
+    var _tabs_index, _ref;
+    const index = state.tabs.findIndex((open)=>open.param === param);
+    if (index === -1) return state;
+    const tabs = state.tabs.filter((open)=>open.param !== param);
+    if (state.activeParam !== param) {
+        return {
+            tabs,
+            activeParam: state.activeParam
+        };
+    }
+    const neighbour = (_tabs_index = tabs[index]) != null ? _tabs_index : tabs[index - 1];
+    return {
+        tabs,
+        activeParam: (_ref = neighbour == null ? void 0 : neighbour.param) != null ? _ref : null
+    };
+}
+/** Focus an open tab; focusing an unknown one is a no-op. */ export function setActive(state, param) {
+    if (!state.tabs.some((open)=>open.param === param)) return state;
+    return _extends({}, state, {
+        activeParam: param
+    });
+}
+
+//# sourceMappingURL=tab-state.js.map

package/dist/lib/workspace/tab-state.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/workspace/tab-state.ts"],"sourcesContent":["/**\n * A single open tab. `param` is its `?tab=` value — both the deep-link address\n * and the tab's identity, so opening the same address twice focuses the one\n * that is already open rather than duplicating it.\n */\nexport interface TabRecord {\n  param: string;\n  title: string;\n}\n\nexport interface TabsSnapshot {\n  tabs: TabRecord[];\n  activeParam: string | null;\n}\n\nexport const emptyTabs: TabsSnapshot = { tabs: [], activeParam: null };\n\n/** Upper bound on open tabs before the oldest inactive one is evicted. */\nexport const MAX_TABS = 12;\n\n/**\n * Trim the set to {@link MAX_TABS} by evicting the oldest tabs first, never the\n * active one. Evicting a tab does not lose its work — any draft survives in\n * IndexedDB and is restored when the tab is reopened.\n */\nexport function capTabs(state: TabsSnapshot): TabsSnapshot {\n  let overflow = state.tabs.length - MAX_TABS;\n  if (overflow <= 0) return state;\n\n  const tabs = state.tabs.filter(open => {\n    if (overflow > 0 && open.param !== state.activeParam) {\n      overflow -= 1;\n      return false;\n    }\n    return true;\n  });\n  return { ...state, tabs };\n}\n\n/**\n * Open a tab, or focus and re-title it if its address is already open. The\n * opened/focused tab becomes active; the set is capped at {@link MAX_TABS}.\n */\nexport function openOrFocus(state: TabsSnapshot, tab: TabRecord): TabsSnapshot {\n  const existing = state.tabs.find(open => open.param === tab.param);\n  // Re-opening the tab that is already open and already active changes nothing;\n  // returning the same snapshot keeps subscribers from re-rendering on every\n  // URL⇄store sync, which is what turned a settled workspace into a churn of\n  // new tab arrays.\n  if (existing?.title === tab.title && state.activeParam === tab.param) {\n    return state;\n  }\n\n  const exists = existing !== undefined;\n  const tabs = exists\n    ? state.tabs.map(open =>\n        open.param === tab.param ? { ...open, title: tab.title } : open,\n      )\n    : [...state.tabs, tab];\n  return capTabs({ tabs, activeParam: tab.param });\n}\n\n/**\n * Close a tab. If it was active, focus its neighbour (the tab that slides into\n * its place, else the one before it, else nothing). Closing an unknown tab is a\n * no-op.\n */\nexport function closeTab(state: TabsSnapshot, param: string): TabsSnapshot {\n  const index = state.tabs.findIndex(open => open.param === param);\n  if (index === -1) return state;\n\n  const tabs = state.tabs.filter(open => open.param !== param);\n  if (state.activeParam !== param) {\n    return { tabs, activeParam: state.activeParam };\n  }\n\n  const neighbour = tabs[index] ?? tabs[index - 1];\n  return { tabs, activeParam: neighbour?.param ?? null };\n}\n\n/** Focus an open tab; focusing an unknown one is a no-op. */\nexport function setActive(state: TabsSnapshot, param: string): TabsSnapshot {\n  if (!state.tabs.some(open => open.param === param)) return state;\n  return { ...state, activeParam: param };\n}\n"],"names":["emptyTabs","tabs","activeParam","MAX_TABS","capTabs","state","overflow","length","filter","open","param","openOrFocus","tab","existing","find","title","exists","undefined","map","closeTab","index","findIndex","neighbour","setActive","some"],"mappings":"AAAA;;;;CAIC;AAWD,OAAO,MAAMA,YAA0B;IAAEC,MAAM,EAAE;IAAEC,aAAa;AAAK,EAAE;AAEvE,wEAAwE,GACxE,OAAO,MAAMC,WAAW,GAAG;AAE3B;;;;CAIC,GACD,OAAO,SAASC,QAAQC,KAAmB;IACzC,IAAIC,WAAWD,MAAMJ,IAAI,CAACM,MAAM,GAAGJ;IACnC,IAAIG,YAAY,GAAG,OAAOD;IAE1B,MAAMJ,OAAOI,MAAMJ,IAAI,CAACO,MAAM,CAACC,CAAAA;QAC7B,IAAIH,WAAW,KAAKG,KAAKC,KAAK,KAAKL,MAAMH,WAAW,EAAE;YACpDI,YAAY;YACZ,OAAO;QACT;QACA,OAAO;IACT;IACA,OAAO,aAAKD;QAAOJ;;AACrB;AAEA;;;CAGC,GACD,OAAO,SAASU,YAAYN,KAAmB,EAAEO,GAAc;IAC7D,MAAMC,WAAWR,MAAMJ,IAAI,CAACa,IAAI,CAACL,CAAAA,OAAQA,KAAKC,KAAK,KAAKE,IAAIF,KAAK;IACjE,8EAA8E;IAC9E,2EAA2E;IAC3E,2EAA2E;IAC3E,kBAAkB;IAClB,IAAIG,CAAAA,4BAAAA,SAAUE,KAAK,MAAKH,IAAIG,KAAK,IAAIV,MAAMH,WAAW,KAAKU,IAAIF,KAAK,EAAE;QACpE,OAAOL;IACT;IAEA,MAAMW,SAASH,aAAaI;IAC5B,MAAMhB,OAAOe,SACTX,MAAMJ,IAAI,CAACiB,GAAG,CAACT,CAAAA,OACbA,KAAKC,KAAK,KAAKE,IAAIF,KAAK,GAAG,aAAKD;YAAMM,OAAOH,IAAIG,KAAK;aAAKN,QAE7D;WAAIJ,MAAMJ,IAAI;QAAEW;KAAI;IACxB,OAAOR,QAAQ;QAAEH;QAAMC,aAAaU,IAAIF,KAAK;IAAC;AAChD;AAEA;;;;CAIC,GACD,OAAO,SAASS,SAASd,KAAmB,EAAEK,KAAa;QASvCT;IARlB,MAAMmB,QAAQf,MAAMJ,IAAI,CAACoB,SAAS,CAACZ,CAAAA,OAAQA,KAAKC,KAAK,KAAKA;IAC1D,IAAIU,UAAU,CAAC,GAAG,OAAOf;IAEzB,MAAMJ,OAAOI,MAAMJ,IAAI,CAACO,MAAM,CAACC,CAAAA,OAAQA,KAAKC,KAAK,KAAKA;IACtD,IAAIL,MAAMH,WAAW,KAAKQ,OAAO;QAC/B,OAAO;YAAET;YAAMC,aAAaG,MAAMH,WAAW;QAAC;IAChD;IAEA,MAAMoB,aAAYrB,cAAAA,IAAI,CAACmB,MAAM,YAAXnB,cAAeA,IAAI,CAACmB,QAAQ,EAAE;IAChD,OAAO;QAAEnB;QAAMC,WAAW,UAAEoB,6BAAAA,UAAWZ,KAAK,mBAAI;IAAK;AACvD;AAEA,2DAA2D,GAC3D,OAAO,SAASa,UAAUlB,KAAmB,EAAEK,KAAa;IAC1D,IAAI,CAACL,MAAMJ,IAAI,CAACuB,IAAI,CAACf,CAAAA,OAAQA,KAAKC,KAAK,KAAKA,QAAQ,OAAOL;IAC3D,OAAO,aAAKA;QAAOH,aAAaQ;;AAClC"}

package/dist/lib/workspace/tabs-state.d.ts

@@ -0,0 +1,46 @@
+import { type TabRecord, type TabsSnapshot } from './tab-state.js';
+export interface TabsState extends TabsSnapshot {
+    open(tab: TabRecord): void;
+    close(param: string): void;
+    activate(param: string): void;
+}
+/** Only the data is persisted — the action functions are re-created on load. */
+export declare function persistedTabs(store: TabsState): TabsSnapshot;
+export declare const WORKSPACE_DB = "entifix-workspace";
+/**
+ * Bump when {@link TabsSnapshot}'s shape changes, and every persisted tab set is
+ * discarded on the next load.
+ *
+ * Restoring a snapshot this build cannot read is worse than opening empty: a tab
+ * whose `param` no longer resolves renders the workspace's dead-link fallback,
+ * so a drifted snapshot is a strip of broken tabs rather than an error anyone
+ * can act on.
+ */
+export declare const TABS_VERSION = 2;
+/**
+ * Discard, never guess — see {@link migrateDrafts} for the same decision on the
+ * other store, and for why this is written out instead of left to zustand's
+ * default (which discards too, but logs an error while doing it).
+ */
+export declare function migrateTabs(): TabsSnapshot;
+/**
+ * The open tab set, persisted to IndexedDB so a refresh restores the workspace.
+ * Hydration is skipped on creation (it would touch IndexedDB during SSR) and
+ * triggered from the client by `WorkspaceShell`, which also holds every URL
+ * effect back until the read has landed — otherwise the restored `activeParam`
+ * overwrites a `?tab=` deep link.
+ */
+export declare const useTabsState: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<TabsState>, "setState" | "persist"> & {
+    setState(partial: TabsState | Partial<TabsState> | ((state: TabsState) => TabsState | Partial<TabsState>), replace?: false | undefined): unknown;
+    setState(state: TabsState | ((state: TabsState) => TabsState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<TabsState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: TabsState) => void) => () => void;
+        onFinishHydration: (fn: (state: TabsState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<TabsState, unknown, unknown>>;
+    };
+}>;
+//# sourceMappingURL=tabs-state.d.ts.map

package/dist/lib/workspace/tabs-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabs-state.d.ts","sourceRoot":"","sources":["../../../src/lib/workspace/tabs-state.ts"],"names":[],"mappings":"AAMA,OAAO,EAKL,KAAK,SAAS,EACd,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AAExB,MAAM,WAAW,SAAU,SAAQ,YAAY;IAC7C,IAAI,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IAC3B,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,YAAY,CAE5D;AAED,eAAO,MAAM,YAAY,sBAAsB,CAAC;AAGhD;;;;;;;;GAQG;AAIH,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,YAAY,CAE1C;AAED;;;;;;GAMG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;EAsBxB,CAAC"}

package/dist/lib/workspace/tabs-state.js

@@ -0,0 +1,56 @@
+'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { create } from 'zustand';
+import { createJSONStorage, persist } from 'zustand/middleware';
+import { makeIndexedDbStateStorage } from './idb-state-storage.js';
+import { closeTab, emptyTabs, openOrFocus, setActive } from './tab-state.js';
+/** Only the data is persisted — the action functions are re-created on load. */ export function persistedTabs(store) {
+    return {
+        tabs: store.tabs,
+        activeParam: store.activeParam
+    };
+}
+export const WORKSPACE_DB = 'entifix-workspace';
+const WORKSPACE_STORE = 'stores';
+/**
+ * Bump when {@link TabsSnapshot}'s shape changes, and every persisted tab set is
+ * discarded on the next load.
+ *
+ * Restoring a snapshot this build cannot read is worse than opening empty: a tab
+ * whose `param` no longer resolves renders the workspace's dead-link fallback,
+ * so a drifted snapshot is a strip of broken tabs rather than an error anyone
+ * can act on.
+ */ // 2: the tab address became `<screenType>:<key>[:<id>]` (ADR 0042), so every
+// `catalog:` / `entity:` / `system:` param a previous build persisted addresses
+// a kind that no longer exists.
+export const TABS_VERSION = 2;
+/**
+ * Discard, never guess — see {@link migrateDrafts} for the same decision on the
+ * other store, and for why this is written out instead of left to zustand's
+ * default (which discards too, but logs an error while doing it).
+ */ export function migrateTabs() {
+    return emptyTabs;
+}
+/**
+ * The open tab set, persisted to IndexedDB so a refresh restores the workspace.
+ * Hydration is skipped on creation (it would touch IndexedDB during SSR) and
+ * triggered from the client by `WorkspaceShell`, which also holds every URL
+ * effect back until the read has landed — otherwise the restored `activeParam`
+ * overwrites a `?tab=` deep link.
+ */ export const useTabsState = create()(persist((set)=>_extends({}, emptyTabs, {
+        open: (tab)=>set((state)=>openOrFocus(state, tab)),
+        close: (param)=>set((state)=>closeTab(state, param)),
+        activate: (param)=>set((state)=>setActive(state, param))
+    }), {
+    // Replaced with a scoped name by `WorkspaceShell` before it rehydrates —
+    // see `workspace-scope.ts`. Nothing rehydrates without passing through
+    // that call, so this literal is only what an unscoped store would write.
+    name: 'tabs',
+    version: TABS_VERSION,
+    migrate: migrateTabs,
+    storage: createJSONStorage(()=>makeIndexedDbStateStorage(WORKSPACE_DB, WORKSPACE_STORE)),
+    partialize: persistedTabs,
+    skipHydration: true
+}));
+
+//# sourceMappingURL=tabs-state.js.map

package/dist/lib/workspace/tabs-state.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/workspace/tabs-state.ts"],"sourcesContent":["'use client';\n\nimport { create } from 'zustand';\nimport { createJSONStorage, persist } from 'zustand/middleware';\n\nimport { makeIndexedDbStateStorage } from './idb-state-storage.js';\nimport {\n  closeTab,\n  emptyTabs,\n  openOrFocus,\n  setActive,\n  type TabRecord,\n  type TabsSnapshot,\n} from './tab-state.js';\n\nexport interface TabsState extends TabsSnapshot {\n  open(tab: TabRecord): void;\n  close(param: string): void;\n  activate(param: string): void;\n}\n\n/** Only the data is persisted — the action functions are re-created on load. */\nexport function persistedTabs(store: TabsState): TabsSnapshot {\n  return { tabs: store.tabs, activeParam: store.activeParam };\n}\n\nexport const WORKSPACE_DB = 'entifix-workspace';\nconst WORKSPACE_STORE = 'stores';\n\n/**\n * Bump when {@link TabsSnapshot}'s shape changes, and every persisted tab set is\n * discarded on the next load.\n *\n * Restoring a snapshot this build cannot read is worse than opening empty: a tab\n * whose `param` no longer resolves renders the workspace's dead-link fallback,\n * so a drifted snapshot is a strip of broken tabs rather than an error anyone\n * can act on.\n */\n// 2: the tab address became `<screenType>:<key>[:<id>]` (ADR 0042), so every\n// `catalog:` / `entity:` / `system:` param a previous build persisted addresses\n// a kind that no longer exists.\nexport const TABS_VERSION = 2;\n\n/**\n * Discard, never guess — see {@link migrateDrafts} for the same decision on the\n * other store, and for why this is written out instead of left to zustand's\n * default (which discards too, but logs an error while doing it).\n */\nexport function migrateTabs(): TabsSnapshot {\n  return emptyTabs;\n}\n\n/**\n * The open tab set, persisted to IndexedDB so a refresh restores the workspace.\n * Hydration is skipped on creation (it would touch IndexedDB during SSR) and\n * triggered from the client by `WorkspaceShell`, which also holds every URL\n * effect back until the read has landed — otherwise the restored `activeParam`\n * overwrites a `?tab=` deep link.\n */\nexport const useTabsState = create<TabsState>()(\n  persist(\n    set => ({\n      ...emptyTabs,\n      open: tab => set(state => openOrFocus(state, tab)),\n      close: param => set(state => closeTab(state, param)),\n      activate: param => set(state => setActive(state, param)),\n    }),\n    {\n      // Replaced with a scoped name by `WorkspaceShell` before it rehydrates —\n      // see `workspace-scope.ts`. Nothing rehydrates without passing through\n      // that call, so this literal is only what an unscoped store would write.\n      name: 'tabs',\n      version: TABS_VERSION,\n      migrate: migrateTabs,\n      storage: createJSONStorage(() =>\n        makeIndexedDbStateStorage(WORKSPACE_DB, WORKSPACE_STORE),\n      ),\n      partialize: persistedTabs,\n      skipHydration: true,\n    },\n  ),\n);\n"],"names":["create","createJSONStorage","persist","makeIndexedDbStateStorage","closeTab","emptyTabs","openOrFocus","setActive","persistedTabs","store","tabs","activeParam","WORKSPACE_DB","WORKSPACE_STORE","TABS_VERSION","migrateTabs","useTabsState","set","open","tab","state","close","param","activate","name","version","migrate","storage","partialize","skipHydration"],"mappings":"AAAA;;AAEA,SAASA,MAAM,QAAQ,UAAU;AACjC,SAASC,iBAAiB,EAAEC,OAAO,QAAQ,qBAAqB;AAEhE,SAASC,yBAAyB,QAAQ,yBAAyB;AACnE,SACEC,QAAQ,EACRC,SAAS,EACTC,WAAW,EACXC,SAAS,QAGJ,iBAAiB;AAQxB,8EAA8E,GAC9E,OAAO,SAASC,cAAcC,KAAgB;IAC5C,OAAO;QAAEC,MAAMD,MAAMC,IAAI;QAAEC,aAAaF,MAAME,WAAW;IAAC;AAC5D;AAEA,OAAO,MAAMC,eAAe,oBAAoB;AAChD,MAAMC,kBAAkB;AAExB;;;;;;;;CAQC,GACD,6EAA6E;AAC7E,gFAAgF;AAChF,gCAAgC;AAChC,OAAO,MAAMC,eAAe,EAAE;AAE9B;;;;CAIC,GACD,OAAO,SAASC;IACd,OAAOV;AACT;AAEA;;;;;;CAMC,GACD,OAAO,MAAMW,eAAehB,SAC1BE,QACEe,CAAAA,MAAQ,aACHZ;QACHa,MAAMC,CAAAA,MAAOF,IAAIG,CAAAA,QAASd,YAAYc,OAAOD;QAC7CE,OAAOC,CAAAA,QAASL,IAAIG,CAAAA,QAAShB,SAASgB,OAAOE;QAC7CC,UAAUD,CAAAA,QAASL,IAAIG,CAAAA,QAASb,UAAUa,OAAOE;QAEnD;IACE,yEAAyE;IACzE,uEAAuE;IACvE,yEAAyE;IACzEE,MAAM;IACNC,SAASX;IACTY,SAASX;IACTY,SAAS1B,kBAAkB,IACzBE,0BAA0BS,cAAcC;IAE1Ce,YAAYpB;IACZqB,eAAe;AACjB,IAEF"}

package/dist/lib/workspace/use-entity-draft.d.ts

@@ -0,0 +1,25 @@
+import type { EntityDraftStore } from '@entifix/react-integration';
+/**
+ * The workspace's implementation of `useEntityForm`'s draft port: binds a form
+ * to the address-keyed draft this workspace persists to IndexedDB.
+ *
+ * The address is the tab's own `?tab=` value, which is what makes a tab's dirty
+ * marker and its close confirmation fall out of the same fact the form is
+ * autosaving into — `WorkspaceShell` reads `drafts` directly and asks nothing
+ * else.
+ *
+ * Handing this to a form is the *whole* opt-in. A plain route hands nothing and
+ * stays ephemeral, by construction rather than by a flag: there is no value of
+ * a missing prop that accidentally starts persisting.
+ *
+ * The returned object is memoised because the port requires a stable `save`:
+ * the hook writes from an effect keyed on it, so a fresh identity each render
+ * would turn every render into an IndexedDB write.
+ *
+ * `'use client'` is load-bearing here, not decoration. This module is reached
+ * through the package's flat client entry, and per-file swc keeps each file's
+ * own directive — a module with hooks and no directive is what drags `useMemo`
+ * into a Server Component's build.
+ */
+export declare function useEntityDraft(address: string): EntityDraftStore;
+//# sourceMappingURL=use-entity-draft.d.ts.map

package/dist/lib/workspace/use-entity-draft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-draft.d.ts","sourceRoot":"","sources":["../../../src/lib/workspace/use-entity-draft.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAKnE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAOhE"}

package/dist/lib/workspace/use-entity-draft.js

@@ -0,0 +1,38 @@
+'use client';
+import { useMemo } from 'react';
+import { useDraft } from './drafts-state.js';
+/**
+ * The workspace's implementation of `useEntityForm`'s draft port: binds a form
+ * to the address-keyed draft this workspace persists to IndexedDB.
+ *
+ * The address is the tab's own `?tab=` value, which is what makes a tab's dirty
+ * marker and its close confirmation fall out of the same fact the form is
+ * autosaving into — `WorkspaceShell` reads `drafts` directly and asks nothing
+ * else.
+ *
+ * Handing this to a form is the *whole* opt-in. A plain route hands nothing and
+ * stays ephemeral, by construction rather than by a flag: there is no value of
+ * a missing prop that accidentally starts persisting.
+ *
+ * The returned object is memoised because the port requires a stable `save`:
+ * the hook writes from an effect keyed on it, so a fresh identity each render
+ * would turn every render into an IndexedDB write.
+ *
+ * `'use client'` is load-bearing here, not decoration. This module is reached
+ * through the package's flat client entry, and per-file swc keeps each file's
+ * own directive — a module with hooks and no directive is what drags `useMemo`
+ * into a Server Component's build.
+ */ export function useEntityDraft(address) {
+    const { draft, setDraft, clearDraft } = useDraft(address);
+    return useMemo(()=>({
+            draft,
+            save: setDraft,
+            clear: clearDraft
+        }), [
+        draft,
+        setDraft,
+        clearDraft
+    ]);
+}
+
+//# sourceMappingURL=use-entity-draft.js.map

package/dist/lib/workspace/use-entity-draft.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/workspace/use-entity-draft.ts"],"sourcesContent":["'use client';\n\nimport type { EntityDraft } from '@entifix/core';\nimport type { EntityDraftStore } from '@entifix/react-integration';\nimport { useMemo } from 'react';\n\nimport { useDraft } from './drafts-state.js';\n\n/**\n * The workspace's implementation of `useEntityForm`'s draft port: binds a form\n * to the address-keyed draft this workspace persists to IndexedDB.\n *\n * The address is the tab's own `?tab=` value, which is what makes a tab's dirty\n * marker and its close confirmation fall out of the same fact the form is\n * autosaving into — `WorkspaceShell` reads `drafts` directly and asks nothing\n * else.\n *\n * Handing this to a form is the *whole* opt-in. A plain route hands nothing and\n * stays ephemeral, by construction rather than by a flag: there is no value of\n * a missing prop that accidentally starts persisting.\n *\n * The returned object is memoised because the port requires a stable `save`:\n * the hook writes from an effect keyed on it, so a fresh identity each render\n * would turn every render into an IndexedDB write.\n *\n * `'use client'` is load-bearing here, not decoration. This module is reached\n * through the package's flat client entry, and per-file swc keeps each file's\n * own directive — a module with hooks and no directive is what drags `useMemo`\n * into a Server Component's build.\n */\nexport function useEntityDraft(address: string): EntityDraftStore {\n  const { draft, setDraft, clearDraft } = useDraft<EntityDraft>(address);\n\n  return useMemo(\n    () => ({ draft, save: setDraft, clear: clearDraft }),\n    [draft, setDraft, clearDraft],\n  );\n}\n"],"names":["useMemo","useDraft","useEntityDraft","address","draft","setDraft","clearDraft","save","clear"],"mappings":"AAAA;AAIA,SAASA,OAAO,QAAQ,QAAQ;AAEhC,SAASC,QAAQ,QAAQ,oBAAoB;AAE7C;;;;;;;;;;;;;;;;;;;;;CAqBC,GACD,OAAO,SAASC,eAAeC,OAAe;IAC5C,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAEC,UAAU,EAAE,GAAGL,SAAsBE;IAE9D,OAAOH,QACL,IAAO,CAAA;YAAEI;YAAOG,MAAMF;YAAUG,OAAOF;QAAW,CAAA,GAClD;QAACF;QAAOC;QAAUC;KAAW;AAEjC"}

package/dist/lib/workspace/workspace-scope.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Who a persisted workspace belongs to.
+ *
+ * Tabs and drafts live in IndexedDB, which is a property of the *browser
+ * profile*, not of the session. Without a scope two accounts signing in on one
+ * machine share both stores: the second sees the first's open tabs and restores
+ * their half-finished edits. A draft is keyed by a record's address
+ * (`entity:product-specification:<id>`) and a record id is tenant-scoped, so a
+ * draft written under one organization and restored under another would post
+ * into the wrong tenant.
+ *
+ * The organization is part of the key for that reason, not only the user: a
+ * party may hold several memberships and switching re-mints the token
+ * (`TokenClaims.activeOrganizationId`).
+ */
+export interface WorkspaceScopeParts {
+    /** The canonical user id — `TokenClaims.userId`. */
+    readonly userId: string;
+    /**
+     * The organization the session is acting for, when it has one. A buyer and an
+     * operator hold no tenant scope at all, which is a legitimate scope of its
+     * own rather than a missing value.
+     */
+    readonly organizationId?: string;
+}
+/**
+ * The storage key suffix for one signed-in principal.
+ *
+ * ⚠️ **This is a separation mechanism, not a confidentiality boundary.** Anyone
+ * holding the browser profile can read every key in the object store, and they
+ * hold the session cookie too — the key stops an accidental cross-account
+ * restore, nothing more. It follows that deriving it from unverified token
+ * claims is safe: forging one shows you your own drafts under a different name,
+ * and every request behind a restored draft is still authorized by the service
+ * that answers it. Same reasoning as the nav's `unverifiedClaims` read.
+ *
+ * A session with no organization is scoped explicitly rather than left blank, so
+ * `user-1` with no organization and `user-1` acting for organization `-` are not
+ * the same workspace by accident.
+ */
+export declare function workspaceScopeKey({ userId, organizationId, }: WorkspaceScopeParts): string;
+/**
+ * The scope for a visitor whose principal could not be read — an expired cookie
+ * behind a page that still rendered, say.
+ *
+ * It is a real, separate scope rather than an empty string: falling back to the
+ * unscoped key would hand an unidentified visitor whatever the last signed-in
+ * account left behind, which is the exact failure the scope exists to prevent.
+ */
+export declare const ANONYMOUS_WORKSPACE_SCOPE = "anonymous";
+//# sourceMappingURL=workspace-scope.d.ts.map

package/dist/lib/workspace/workspace-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-scope.d.ts","sourceRoot":"","sources":["../../../src/lib/workspace/workspace-scope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,mBAAmB;IAClC,oDAAoD;IACpD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAKD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,MAAM,EACN,cAAc,GACf,EAAE,mBAAmB,GAAG,MAAM,CAE9B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,cAAc,CAAC"}

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

@@ -0,0 +1,42 @@
+/**
+ * Who a persisted workspace belongs to.
+ *
+ * Tabs and drafts live in IndexedDB, which is a property of the *browser
+ * profile*, not of the session. Without a scope two accounts signing in on one
+ * machine share both stores: the second sees the first's open tabs and restores
+ * their half-finished edits. A draft is keyed by a record's address
+ * (`entity:product-specification:<id>`) and a record id is tenant-scoped, so a
+ * draft written under one organization and restored under another would post
+ * into the wrong tenant.
+ *
+ * The organization is part of the key for that reason, not only the user: a
+ * party may hold several memberships and switching re-mints the token
+ * (`TokenClaims.activeOrganizationId`).
+ */ /** What an absent `activeOrganizationId` is stored as — see {@link workspaceScopeKey}. */ const NO_ORGANIZATION = '-';
+/**
+ * The storage key suffix for one signed-in principal.
+ *
+ * ⚠️ **This is a separation mechanism, not a confidentiality boundary.** Anyone
+ * holding the browser profile can read every key in the object store, and they
+ * hold the session cookie too — the key stops an accidental cross-account
+ * restore, nothing more. It follows that deriving it from unverified token
+ * claims is safe: forging one shows you your own drafts under a different name,
+ * and every request behind a restored draft is still authorized by the service
+ * that answers it. Same reasoning as the nav's `unverifiedClaims` read.
+ *
+ * A session with no organization is scoped explicitly rather than left blank, so
+ * `user-1` with no organization and `user-1` acting for organization `-` are not
+ * the same workspace by accident.
+ */ export function workspaceScopeKey({ userId, organizationId }) {
+    return `${userId}:${organizationId != null ? organizationId : NO_ORGANIZATION}`;
+}
+/**
+ * The scope for a visitor whose principal could not be read — an expired cookie
+ * behind a page that still rendered, say.
+ *
+ * It is a real, separate scope rather than an empty string: falling back to the
+ * unscoped key would hand an unidentified visitor whatever the last signed-in
+ * account left behind, which is the exact failure the scope exists to prevent.
+ */ export const ANONYMOUS_WORKSPACE_SCOPE = 'anonymous';
+
+//# sourceMappingURL=workspace-scope.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/workspace/workspace-scope.ts"],"sourcesContent":["/**\n * Who a persisted workspace belongs to.\n *\n * Tabs and drafts live in IndexedDB, which is a property of the *browser\n * profile*, not of the session. Without a scope two accounts signing in on one\n * machine share both stores: the second sees the first's open tabs and restores\n * their half-finished edits. A draft is keyed by a record's address\n * (`entity:product-specification:<id>`) and a record id is tenant-scoped, so a\n * draft written under one organization and restored under another would post\n * into the wrong tenant.\n *\n * The organization is part of the key for that reason, not only the user: a\n * party may hold several memberships and switching re-mints the token\n * (`TokenClaims.activeOrganizationId`).\n */\nexport interface WorkspaceScopeParts {\n  /** The canonical user id — `TokenClaims.userId`. */\n  readonly userId: string;\n  /**\n   * The organization the session is acting for, when it has one. A buyer and an\n   * operator hold no tenant scope at all, which is a legitimate scope of its\n   * own rather than a missing value.\n   */\n  readonly organizationId?: string;\n}\n\n/** What an absent `activeOrganizationId` is stored as — see {@link workspaceScopeKey}. */\nconst NO_ORGANIZATION = '-';\n\n/**\n * The storage key suffix for one signed-in principal.\n *\n * ⚠️ **This is a separation mechanism, not a confidentiality boundary.** Anyone\n * holding the browser profile can read every key in the object store, and they\n * hold the session cookie too — the key stops an accidental cross-account\n * restore, nothing more. It follows that deriving it from unverified token\n * claims is safe: forging one shows you your own drafts under a different name,\n * and every request behind a restored draft is still authorized by the service\n * that answers it. Same reasoning as the nav's `unverifiedClaims` read.\n *\n * A session with no organization is scoped explicitly rather than left blank, so\n * `user-1` with no organization and `user-1` acting for organization `-` are not\n * the same workspace by accident.\n */\nexport function workspaceScopeKey({\n  userId,\n  organizationId,\n}: WorkspaceScopeParts): string {\n  return `${userId}:${organizationId ?? NO_ORGANIZATION}`;\n}\n\n/**\n * The scope for a visitor whose principal could not be read — an expired cookie\n * behind a page that still rendered, say.\n *\n * It is a real, separate scope rather than an empty string: falling back to the\n * unscoped key would hand an unidentified visitor whatever the last signed-in\n * account left behind, which is the exact failure the scope exists to prevent.\n */\nexport const ANONYMOUS_WORKSPACE_SCOPE = 'anonymous';\n"],"names":["NO_ORGANIZATION","workspaceScopeKey","userId","organizationId","ANONYMOUS_WORKSPACE_SCOPE"],"mappings":"AAAA;;;;;;;;;;;;;;CAcC,GAYD,wFAAwF,GACxF,MAAMA,kBAAkB;AAExB;;;;;;;;;;;;;;CAcC,GACD,OAAO,SAASC,kBAAkB,EAChCC,MAAM,EACNC,cAAc,EACM;IACpB,OAAO,GAAGD,OAAO,CAAC,EAAEC,yBAAAA,iBAAkBH,iBAAiB;AACzD;AAEA;;;;;;;CAOC,GACD,OAAO,MAAMI,4BAA4B,YAAY"}

package/dist/lib/workspace/workspace-shell.d.ts

@@ -0,0 +1,33 @@
+import { type ReactNode } from 'react';
+import type { TabRegistry } from './tab-kind.js';
+export interface WorkspaceShellProps {
+    /**
+     * Who this workspace belongs to — `workspaceScopeKey({ userId,
+     * organizationId })`, resolved on the server from the session.
+     *
+     * Required, deliberately: IndexedDB is a property of the browser profile, so a
+     * host that forgets to pass one hands the next account to sign in on that
+     * machine the previous account's open tabs and half-finished edits. A default
+     * would make that the quiet outcome of doing nothing.
+     */
+    scope: string;
+    /** Resolves `?tab=` values to renderable tabs. */
+    registry: TabRegistry;
+    /** Right-aligned actions above the tab strip (search, the user menu). */
+    actions?: ReactNode;
+    /** Body when `?tab=` names something the registry cannot resolve. */
+    fallback?: ReactNode;
+    /** Body when no tab is open. */
+    emptyState?: ReactNode;
+}
+/**
+ * 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 declare function WorkspaceShell({ scope, registry, actions, fallback, emptyState, }: WorkspaceShellProps): import("react").JSX.Element;
+//# sourceMappingURL=workspace-shell.d.ts.map

package/dist/lib/workspace/workspace-shell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-shell.d.ts","sourceRoot":"","sources":["../../../src/lib/workspace/workspace-shell.tsx"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,SAAS,EAAuB,MAAM,OAAO,CAAC;AAG5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAGjD,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;OAQG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,QAAQ,EAAE,WAAW,CAAC;IACtB,yEAAyE;IACzE,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,qEAAqE;IACrE,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,gCAAgC;IAChC,UAAU,CAAC,EAAE,SAAS,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,EAC7B,KAAK,EACL,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,UAAU,GACX,EAAE,mBAAmB,+BA+LrB"}