@entifix/next-shell 0.1.0-0

package/dist/lib/wizard/use-wizard-step-param.js

@@ -0,0 +1,94 @@
+'use client';
+import { usePathname, useRouter, useSearchParams } from 'next/navigation';
+import { useCallback, useEffect, useRef } from 'react';
+/** The query parameter a wizard route carries its step in. */ export const WIZARD_STEP_PARAM = 'step';
+/**
+ * Builds this route's address with a step in it.
+ *
+ * Shared by the writer and the follower so the two cannot disagree about the
+ * shape — and so neither drops the rest of the query, which on a workspace host
+ * is the `?tab=` value naming the tab the wizard is inside.
+ */ function useStepAddress() {
+    const pathname = usePathname();
+    const searchParams = useSearchParams();
+    return useCallback((stepId)=>{
+        const next = new URLSearchParams(searchParams);
+        next.set(WIZARD_STEP_PARAM, stepId);
+        return `${pathname}?${next.toString()}`;
+    }, [
+        pathname,
+        searchParams
+    ]);
+}
+/**
+ * Writes a step into the address — what `useWizard`'s `onStepChange` is wired to.
+ *
+ * ⚠️ **This must be handed to `useWizard` directly, never through a ref.** The
+ * push has to land in the same commit as the move: the follower below compares
+ * the address with the active step, so a report that arrives a tick late leaves
+ * the two disagreeing, and the follower reads that as a Back and moves the
+ * wizard *back* to the step it just left. Splitting the writer from the follower
+ * is what removes the cycle that made a ref look necessary.
+ *
+ * It **checks the address before pushing**, and that guard is what stops the
+ * loop: a Back drives `goTo`, which reports the move, which would otherwise push
+ * the very address Back had just restored — turning one press into an entry the
+ * operator has to get past twice.
+ */ export function useWizardStepUrl() {
+    const router = useRouter();
+    const searchParams = useSearchParams();
+    const addressOf = useStepAddress();
+    return useCallback((stepId)=>{
+        if (searchParams.get(WIZARD_STEP_PARAM) === stepId) return;
+        router.push(addressOf(stepId));
+    }, [
+        router,
+        searchParams,
+        addressOf
+    ]);
+}
+/**
+ * Moves the wizard when the address moves, so browser-Back moves a step instead
+ * of leaving the flow.
+ *
+ * **Back works; Forward deliberately does not re-advance.** Going back pops the
+ * history, so the step Forward names is no longer on the path and `goTo` ignores
+ * it — re-entering it would skip the per-step submit that validated everything
+ * in between, which is the only thing gating advancement.
+ *
+ * An address carrying **no** step means the flow's beginning — which is where
+ * browser-Back from the second step lands, since the first step is never pushed.
+ *
+ * ⚠️ **It reacts to the address *changing*, never to what the address says.**
+ * Two faults sit on either side of that, and both were measured:
+ *
+ * - *Rewriting the address to match the wizard* races the advance. The replace
+ *   is scheduled at mount with the entry step captured, the operator advances
+ *   before it lands, and the navigation then puts the older step back — this
+ *   effect reads it and rewinds a step they had already passed. It appeared only
+ *   under load, which is the kind of race that reaches a user and not a test.
+ * - *Acting on the address at mount* breaks resume. A restored wizard takes its
+ *   position from the persisted draft, so it opens on step four with an address
+ *   that says nothing — read as "the beginning", that sends it back to step one
+ *   and the resume is undone.
+ *
+ * So the first address seen is a **baseline**, and only a move away from it is a
+ * navigation. One direction throughout: the writer owns the address, the
+ * follower owns the wizard.
+ */ export function useFollowWizardStepUrl({ activeStep, entryStep, goTo }) {
+    var _searchParams_get;
+    const searchParams = useSearchParams();
+    const target = (_searchParams_get = searchParams.get(WIZARD_STEP_PARAM)) != null ? _searchParams_get : entryStep;
+    const seen = useRef(target);
+    useEffect(()=>{
+        if (target === seen.current) return;
+        seen.current = target;
+        if (target !== activeStep) goTo(target);
+    }, [
+        target,
+        activeStep,
+        goTo
+    ]);
+}
+
+//# sourceMappingURL=use-wizard-step-param.js.map

package/dist/lib/wizard/use-wizard-step-param.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/wizard/use-wizard-step-param.ts"],"sourcesContent":["'use client';\n\nimport { usePathname, useRouter, useSearchParams } from 'next/navigation';\nimport { useCallback, useEffect, useRef } from 'react';\n\n/** The query parameter a wizard route carries its step in. */\nexport const WIZARD_STEP_PARAM = 'step';\n\n/**\n * Builds this route's address with a step in it.\n *\n * Shared by the writer and the follower so the two cannot disagree about the\n * shape — and so neither drops the rest of the query, which on a workspace host\n * is the `?tab=` value naming the tab the wizard is inside.\n */\nfunction useStepAddress(): (stepId: string) => string {\n  const pathname = usePathname();\n  const searchParams = useSearchParams();\n\n  return useCallback(\n    (stepId: string) => {\n      const next = new URLSearchParams(searchParams);\n      next.set(WIZARD_STEP_PARAM, stepId);\n      return `${pathname}?${next.toString()}`;\n    },\n    [pathname, searchParams],\n  );\n}\n\n/**\n * Writes a step into the address — what `useWizard`'s `onStepChange` is wired to.\n *\n * ⚠️ **This must be handed to `useWizard` directly, never through a ref.** The\n * push has to land in the same commit as the move: the follower below compares\n * the address with the active step, so a report that arrives a tick late leaves\n * the two disagreeing, and the follower reads that as a Back and moves the\n * wizard *back* to the step it just left. Splitting the writer from the follower\n * is what removes the cycle that made a ref look necessary.\n *\n * It **checks the address before pushing**, and that guard is what stops the\n * loop: a Back drives `goTo`, which reports the move, which would otherwise push\n * the very address Back had just restored — turning one press into an entry the\n * operator has to get past twice.\n */\nexport function useWizardStepUrl(): (stepId: string) => void {\n  const router = useRouter();\n  const searchParams = useSearchParams();\n  const addressOf = useStepAddress();\n\n  return useCallback(\n    (stepId: string) => {\n      if (searchParams.get(WIZARD_STEP_PARAM) === stepId) return;\n      router.push(addressOf(stepId));\n    },\n    [router, searchParams, addressOf],\n  );\n}\n\nexport interface FollowWizardStepUrlOptions {\n  /** Where the wizard currently is, from `useWizard`. */\n  activeStep: string;\n  /** The flow's first step — where an address carrying no step points. */\n  entryStep: string;\n  /**\n   * `useWizard`'s `goTo`. It ignores a step that is not on the path already\n   * walked, which is what makes browser-Forward safe to hand straight to it.\n   */\n  goTo: (stepId: string) => void;\n}\n\n/**\n * Moves the wizard when the address moves, so browser-Back moves a step instead\n * of leaving the flow.\n *\n * **Back works; Forward deliberately does not re-advance.** Going back pops the\n * history, so the step Forward names is no longer on the path and `goTo` ignores\n * it — re-entering it would skip the per-step submit that validated everything\n * in between, which is the only thing gating advancement.\n *\n * An address carrying **no** step means the flow's beginning — which is where\n * browser-Back from the second step lands, since the first step is never pushed.\n *\n * ⚠️ **It reacts to the address *changing*, never to what the address says.**\n * Two faults sit on either side of that, and both were measured:\n *\n * - *Rewriting the address to match the wizard* races the advance. The replace\n *   is scheduled at mount with the entry step captured, the operator advances\n *   before it lands, and the navigation then puts the older step back — this\n *   effect reads it and rewinds a step they had already passed. It appeared only\n *   under load, which is the kind of race that reaches a user and not a test.\n * - *Acting on the address at mount* breaks resume. A restored wizard takes its\n *   position from the persisted draft, so it opens on step four with an address\n *   that says nothing — read as \"the beginning\", that sends it back to step one\n *   and the resume is undone.\n *\n * So the first address seen is a **baseline**, and only a move away from it is a\n * navigation. One direction throughout: the writer owns the address, the\n * follower owns the wizard.\n */\nexport function useFollowWizardStepUrl({\n  activeStep,\n  entryStep,\n  goTo,\n}: FollowWizardStepUrlOptions): void {\n  const searchParams = useSearchParams();\n  const target = searchParams.get(WIZARD_STEP_PARAM) ?? entryStep;\n  const seen = useRef(target);\n\n  useEffect(() => {\n    if (target === seen.current) return;\n    seen.current = target;\n    if (target !== activeStep) goTo(target);\n  }, [target, activeStep, goTo]);\n}\n"],"names":["usePathname","useRouter","useSearchParams","useCallback","useEffect","useRef","WIZARD_STEP_PARAM","useStepAddress","pathname","searchParams","stepId","next","URLSearchParams","set","toString","useWizardStepUrl","router","addressOf","get","push","useFollowWizardStepUrl","activeStep","entryStep","goTo","target","seen","current"],"mappings":"AAAA;AAEA,SAASA,WAAW,EAAEC,SAAS,EAAEC,eAAe,QAAQ,kBAAkB;AAC1E,SAASC,WAAW,EAAEC,SAAS,EAAEC,MAAM,QAAQ,QAAQ;AAEvD,4DAA4D,GAC5D,OAAO,MAAMC,oBAAoB,OAAO;AAExC;;;;;;CAMC,GACD,SAASC;IACP,MAAMC,WAAWR;IACjB,MAAMS,eAAeP;IAErB,OAAOC,YACL,CAACO;QACC,MAAMC,OAAO,IAAIC,gBAAgBH;QACjCE,KAAKE,GAAG,CAACP,mBAAmBI;QAC5B,OAAO,GAAGF,SAAS,CAAC,EAAEG,KAAKG,QAAQ,IAAI;IACzC,GACA;QAACN;QAAUC;KAAa;AAE5B;AAEA;;;;;;;;;;;;;;CAcC,GACD,OAAO,SAASM;IACd,MAAMC,SAASf;IACf,MAAMQ,eAAeP;IACrB,MAAMe,YAAYV;IAElB,OAAOJ,YACL,CAACO;QACC,IAAID,aAAaS,GAAG,CAACZ,uBAAuBI,QAAQ;QACpDM,OAAOG,IAAI,CAACF,UAAUP;IACxB,GACA;QAACM;QAAQP;QAAcQ;KAAU;AAErC;AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BC,GACD,OAAO,SAASG,uBAAuB,EACrCC,UAAU,EACVC,SAAS,EACTC,IAAI,EACuB;QAEZd;IADf,MAAMA,eAAeP;IACrB,MAAMsB,UAASf,oBAAAA,aAAaS,GAAG,CAACZ,8BAAjBG,oBAAuCa;IACtD,MAAMG,OAAOpB,OAAOmB;IAEpBpB,UAAU;QACR,IAAIoB,WAAWC,KAAKC,OAAO,EAAE;QAC7BD,KAAKC,OAAO,GAAGF;QACf,IAAIA,WAAWH,YAAYE,KAAKC;IAClC,GAAG;QAACA;QAAQH;QAAYE;KAAK;AAC/B"}

package/dist/lib/wizard/wizard-tab-kind.d.ts

@@ -0,0 +1,31 @@
+import type { ReactNode } from 'react';
+import type { TabKind } from '../workspace/tab-kind.js';
+/** One wizard a workspace may open, as the registry needs it. */
+export interface WizardTabScreen {
+    /** The tab caption's catalog key — the wizard's name, never the step's. */
+    readonly titleKey: string;
+    /** `step` is the third address segment, absent while the flow is at its first. */
+    render(step: string | undefined): ReactNode;
+}
+/**
+ * The `wizard:` tab kind: `wizard:<key>` opens a flow, `wizard:<key>:<step>`
+ * opens it at a step.
+ *
+ * The third segment is a **step** here and a record under `master:`, which is
+ * the one thing [ADR 0045](../../../../../../../docs/adr/0045-the-wizard-a-step-graph-and-a-submit-that-hands-off.md)
+ * changed about the address grammar — `screenAddress` and `parseScreenPayload`
+ * already produced and accepted the shape.
+ *
+ * **The caption is the wizard's name and not the step's**, deliberately: a tab
+ * whose title changed on every Siguiente would reflow the strip mid-flow and
+ * make an open wizard hard to find again by the name it was opened under.
+ *
+ * A factory rather than a constant, for the reason `masterKind` is built in the
+ * host: which screens a workspace offers is the host's decision, and the shells
+ * that own the wizards may not import each other.
+ */
+export declare function wizardTabKind(screens: Record<string, WizardTabScreen>): TabKind<{
+    key: string;
+    id?: string;
+}>;
+//# sourceMappingURL=wizard-tab-kind.d.ts.map

package/dist/lib/wizard/wizard-tab-kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wizard-tab-kind.d.ts","sourceRoot":"","sources":["../../../src/lib/wizard/wizard-tab-kind.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAExD,iEAAiE;AACjE,MAAM,WAAW,eAAe;IAC9B,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,kFAAkF;IAClF,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC;CAC7C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GACvC,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAavC"}

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

@@ -0,0 +1,33 @@
+'use client';
+import { parseScreenPayload } from '@entifix/authz';
+/**
+ * The `wizard:` tab kind: `wizard:<key>` opens a flow, `wizard:<key>:<step>`
+ * opens it at a step.
+ *
+ * The third segment is a **step** here and a record under `master:`, which is
+ * the one thing [ADR 0045](../../../../../../../docs/adr/0045-the-wizard-a-step-graph-and-a-submit-that-hands-off.md)
+ * changed about the address grammar — `screenAddress` and `parseScreenPayload`
+ * already produced and accepted the shape.
+ *
+ * **The caption is the wizard's name and not the step's**, deliberately: a tab
+ * whose title changed on every Siguiente would reflow the strip mid-flow and
+ * make an open wizard hard to find again by the name it was opened under.
+ *
+ * A factory rather than a constant, for the reason `masterKind` is built in the
+ * host: which screens a workspace offers is the host's decision, and the shells
+ * that own the wizards may not import each other.
+ */ export function wizardTabKind(screens) {
+    return {
+        kind: 'wizard',
+        match: (payload)=>{
+            const parsed = parseScreenPayload(payload);
+            if (parsed === null) return null;
+            return parsed.key in screens ? parsed : null;
+        },
+        toParam: (addr)=>addr.id === undefined ? addr.key : `${addr.key}:${addr.id}`,
+        title: (addr, translate)=>translate(screens[addr.key].titleKey),
+        render: (addr)=>screens[addr.key].render(addr.id)
+    };
+}
+
+//# sourceMappingURL=wizard-tab-kind.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/wizard/wizard-tab-kind.tsx"],"sourcesContent":["'use client';\n\nimport { parseScreenPayload } from '@entifix/authz';\nimport type { ReactNode } from 'react';\n\nimport type { TabKind } from '../workspace/tab-kind.js';\n\n/** One wizard a workspace may open, as the registry needs it. */\nexport interface WizardTabScreen {\n  /** The tab caption's catalog key — the wizard's name, never the step's. */\n  readonly titleKey: string;\n  /** `step` is the third address segment, absent while the flow is at its first. */\n  render(step: string | undefined): ReactNode;\n}\n\n/**\n * The `wizard:` tab kind: `wizard:<key>` opens a flow, `wizard:<key>:<step>`\n * opens it at a step.\n *\n * The third segment is a **step** here and a record under `master:`, which is\n * the one thing [ADR 0045](../../../../../../../docs/adr/0045-the-wizard-a-step-graph-and-a-submit-that-hands-off.md)\n * changed about the address grammar — `screenAddress` and `parseScreenPayload`\n * already produced and accepted the shape.\n *\n * **The caption is the wizard's name and not the step's**, deliberately: a tab\n * whose title changed on every Siguiente would reflow the strip mid-flow and\n * make an open wizard hard to find again by the name it was opened under.\n *\n * A factory rather than a constant, for the reason `masterKind` is built in the\n * host: which screens a workspace offers is the host's decision, and the shells\n * that own the wizards may not import each other.\n */\nexport function wizardTabKind(\n  screens: Record<string, WizardTabScreen>,\n): TabKind<{ key: string; id?: string }> {\n  return {\n    kind: 'wizard',\n    match: payload => {\n      const parsed = parseScreenPayload(payload);\n      if (parsed === null) return null;\n      return parsed.key in screens ? parsed : null;\n    },\n    toParam: addr =>\n      addr.id === undefined ? addr.key : `${addr.key}:${addr.id}`,\n    title: (addr, translate) => translate(screens[addr.key].titleKey),\n    render: addr => screens[addr.key].render(addr.id),\n  };\n}\n"],"names":["parseScreenPayload","wizardTabKind","screens","kind","match","payload","parsed","key","toParam","addr","id","undefined","title","translate","titleKey","render"],"mappings":"AAAA;AAEA,SAASA,kBAAkB,QAAQ,iBAAiB;AAapD;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,SAASC,cACdC,OAAwC;IAExC,OAAO;QACLC,MAAM;QACNC,OAAOC,CAAAA;YACL,MAAMC,SAASN,mBAAmBK;YAClC,IAAIC,WAAW,MAAM,OAAO;YAC5B,OAAOA,OAAOC,GAAG,IAAIL,UAAUI,SAAS;QAC1C;QACAE,SAASC,CAAAA,OACPA,KAAKC,EAAE,KAAKC,YAAYF,KAAKF,GAAG,GAAG,GAAGE,KAAKF,GAAG,CAAC,CAAC,EAAEE,KAAKC,EAAE,EAAE;QAC7DE,OAAO,CAACH,MAAMI,YAAcA,UAAUX,OAAO,CAACO,KAAKF,GAAG,CAAC,CAACO,QAAQ;QAChEC,QAAQN,CAAAA,OAAQP,OAAO,CAACO,KAAKF,GAAG,CAAC,CAACQ,MAAM,CAACN,KAAKC,EAAE;IAClD;AACF"}

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

@@ -0,0 +1,88 @@
+import { type JsonValue } from '@entifix/core';
+/**
+ * Per-address edit drafts, persisted to IndexedDB so an in-progress edit
+ * survives a refresh. Keyed by the tab's `?tab=` param (its address), a draft is
+ * whatever the editor needs to restore its fields; it exists until the user
+ * saves (or discards). This is the "continuous autosave" seam — workspace-host
+ * only, so a plain route stays ephemeral.
+ *
+ * **A draft is JSON round-trippable, period.** It is written through
+ * `createJSONStorage`, so a class instance, an `EntityLink` or a `Date` does not
+ * "mostly survive" — it comes back as something else, silently. {@link JsonValue}
+ * is the compile-time half of that rule and {@link mergeDrafts} the runtime half.
+ * Note that `UiPreferencesState`, the other persisted client store, writes
+ * through IndexedDB's structured clone and *does* keep a `Date`; the two
+ * contracts differ and must not be conflated.
+ */
+export interface DraftsState {
+    drafts: Record<string, JsonValue>;
+    setDraft(address: string, value: JsonValue): void;
+    clearDraft(address: string): void;
+}
+export declare function persistedDrafts(store: DraftsState): Pick<DraftsState, 'drafts'>;
+/**
+ * Bump when the *envelope* changes — how a draft is keyed or wrapped — and every
+ * persisted draft is discarded on the next load.
+ *
+ * It cannot see a change to one entity's members, because a draft is opaque
+ * here: this store holds `JsonValue`, and only the form that wrote one knows
+ * which members it should have. That half is `restoreEntityDraft`, which layers
+ * a restored draft over a freshly seeded one so a drifted member is dropped or
+ * re-seeded rather than rendered.
+ */
+export declare const DRAFTS_VERSION = 2;
+/**
+ * Discard, never guess. A draft whose envelope this build does not understand is
+ * an unfinished edit, not a record — losing it costs a retype, while migrating
+ * it blind risks submitting values whose meaning has changed.
+ *
+ * Written out rather than left to zustand's default, which discards too but logs
+ * `State loaded from storage couldn't be migrated since no migrate function was
+ * provided` while doing it — an error message for a decision that was made on
+ * purpose.
+ */
+export declare function migrateDrafts(): Pick<DraftsState, 'drafts'>;
+/**
+ * Restores only the entries that are actually JSON.
+ *
+ * The type above says what may be written; this is what happens when something
+ * else was, by a build that predates the rule or by a `setDraft` reached through
+ * a cast. Dropping the offending entry keeps one bad draft from taking the whole
+ * workspace's drafts with it — and it is per entry rather than all-or-nothing
+ * for that reason.
+ */
+export declare function mergeDrafts(persistedState: unknown, currentState: DraftsState): DraftsState;
+export declare const useDraftsState: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<DraftsState>, "setState" | "persist"> & {
+    setState(partial: DraftsState | Partial<DraftsState> | ((state: DraftsState) => DraftsState | Partial<DraftsState>), replace?: false | undefined): unknown;
+    setState(state: DraftsState | ((state: DraftsState) => DraftsState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<DraftsState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: DraftsState) => void) => () => void;
+        onFinishHydration: (fn: (state: DraftsState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<DraftsState, unknown, unknown>>;
+    };
+}>;
+/**
+ * Bind an editor to its persisted draft. Returns the current draft (restored
+ * from IndexedDB on mount), a setter the editor calls as fields change, and a
+ * clear for when the edit is committed.
+ *
+ * `TDraft` is constrained to {@link JsonValue}: an editor that wants to autosave
+ * something a JSON round trip would not return is asking for the one thing this
+ * store cannot do, and the compile error is the whole point of the constraint.
+ *
+ * One sharp edge, and the error message does not explain it: **declare a draft
+ * type as a `type`, never an `interface`.** TypeScript gives an interface no
+ * implicit index signature, so even `interface Draft { name: string }` — as JSON
+ * as a value gets — fails the constraint with "Index signature for type 'string'
+ * is missing". A `type` alias of the same shape passes.
+ */
+export declare function useDraft<TDraft extends JsonValue>(address: string): {
+    draft: TDraft | undefined;
+    setDraft: (value: TDraft) => void;
+    clearDraft: () => void;
+};
+//# sourceMappingURL=drafts-state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drafts-state.d.ts","sourceRoot":"","sources":["../../../src/lib/workspace/drafts-state.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAQ5D;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IAClD,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,WAAW,GACjB,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAE7B;AAID;;;;;;;;;GASG;AAGH,eAAO,MAAM,cAAc,IAAI,CAAC;AAIhC;;;;;;;;;GASG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAE3D;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,cAAc,EAAE,OAAO,EACvB,YAAY,EAAE,WAAW,GACxB,WAAW,CASb;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;EA6B1B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,MAAM,SAAS,SAAS,EAAE,OAAO,EAAE,MAAM;;sBAYtD,MAAM;;EAMjB"}

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

@@ -0,0 +1,128 @@
+'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+import { _ as _to_property_key } from "@swc/helpers/_/_to_property_key";
+import { isJsonValue } from '@entifix/core';
+import { useCallback, useEffect } from 'react';
+import { create } from 'zustand';
+import { createJSONStorage, persist } from 'zustand/middleware';
+import { makeIndexedDbStateStorage } from './idb-state-storage.js';
+import { WORKSPACE_DB } from './tabs-state.js';
+export function persistedDrafts(store) {
+    return {
+        drafts: store.drafts
+    };
+}
+const DRAFTS_STORE = 'stores';
+/**
+ * Bump when the *envelope* changes — how a draft is keyed or wrapped — and every
+ * persisted draft is discarded on the next load.
+ *
+ * It cannot see a change to one entity's members, because a draft is opaque
+ * here: this store holds `JsonValue`, and only the form that wrote one knows
+ * which members it should have. That half is `restoreEntityDraft`, which layers
+ * a restored draft over a freshly seeded one so a drifted member is dropped or
+ * re-seeded rather than rendered.
+ */ // 2: a draft is keyed by the tab address, and that grammar changed with
+// ADR 0042 — so every persisted draft is filed under a key nothing will ask for.
+export const DRAFTS_VERSION = 2;
+const emptyDrafts = {
+    drafts: {}
+};
+/**
+ * Discard, never guess. A draft whose envelope this build does not understand is
+ * an unfinished edit, not a record — losing it costs a retype, while migrating
+ * it blind risks submitting values whose meaning has changed.
+ *
+ * Written out rather than left to zustand's default, which discards too but logs
+ * `State loaded from storage couldn't be migrated since no migrate function was
+ * provided` while doing it — an error message for a decision that was made on
+ * purpose.
+ */ export function migrateDrafts() {
+    return emptyDrafts;
+}
+/**
+ * Restores only the entries that are actually JSON.
+ *
+ * The type above says what may be written; this is what happens when something
+ * else was, by a build that predates the rule or by a `setDraft` reached through
+ * a cast. Dropping the offending entry keeps one bad draft from taking the whole
+ * workspace's drafts with it — and it is per entry rather than all-or-nothing
+ * for that reason.
+ */ export function mergeDrafts(persistedState, currentState) {
+    const restored = persistedState == null ? void 0 : persistedState.drafts;
+    if (restored === null || typeof restored !== 'object') return currentState;
+    const drafts = {};
+    for (const [address, value] of Object.entries(restored)){
+        if (isJsonValue(value)) drafts[address] = value;
+    }
+    return _extends({}, currentState, {
+        drafts
+    });
+}
+export const useDraftsState = create()(persist((set)=>({
+        drafts: {},
+        setDraft: (address, value)=>set((state)=>({
+                    drafts: _extends({}, state.drafts, {
+                        [address]: value
+                    })
+                })),
+        clearDraft: (address)=>set((state)=>{
+                if (!(address in state.drafts)) return state;
+                const _state_drafts = state.drafts, { [address]: _removed } = _state_drafts, rest = _object_without_properties_loose(_state_drafts, [
+                    _to_property_key(address)
+                ]);
+                return {
+                    drafts: rest
+                };
+            })
+    }), {
+    // Replaced with a scoped name by `WorkspaceShell` before it rehydrates, so
+    // two accounts on one browser profile do not share drafts. This literal is
+    // only what an unscoped store would write, and nothing rehydrates without
+    // passing through that call.
+    name: 'drafts',
+    version: DRAFTS_VERSION,
+    migrate: migrateDrafts,
+    merge: mergeDrafts,
+    storage: createJSONStorage(()=>makeIndexedDbStateStorage(WORKSPACE_DB, DRAFTS_STORE)),
+    partialize: persistedDrafts,
+    skipHydration: true
+}));
+/**
+ * Bind an editor to its persisted draft. Returns the current draft (restored
+ * from IndexedDB on mount), a setter the editor calls as fields change, and a
+ * clear for when the edit is committed.
+ *
+ * `TDraft` is constrained to {@link JsonValue}: an editor that wants to autosave
+ * something a JSON round trip would not return is asking for the one thing this
+ * store cannot do, and the compile error is the whole point of the constraint.
+ *
+ * One sharp edge, and the error message does not explain it: **declare a draft
+ * type as a `type`, never an `interface`.** TypeScript gives an interface no
+ * implicit index signature, so even `interface Draft { name: string }` — as JSON
+ * as a value gets — fails the constraint with "Index signature for type 'string'
+ * is missing". A `type` alias of the same shape passes.
+ */ export function useDraft(address) {
+    const draft = useDraftsState((state)=>state.drafts[address]);
+    const set = useDraftsState((state)=>state.setDraft);
+    const clear = useDraftsState((state)=>state.clearDraft);
+    useEffect(()=>{
+        void useDraftsState.persist.rehydrate();
+    }, []);
+    const setDraft = useCallback((value)=>set(address, value), [
+        set,
+        address
+    ]);
+    const clearDraft = useCallback(()=>clear(address), [
+        clear,
+        address
+    ]);
+    return {
+        draft,
+        setDraft,
+        clearDraft
+    };
+}
+
+//# sourceMappingURL=drafts-state.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/workspace/drafts-state.ts"],"sourcesContent":["'use client';\n\nimport { isJsonValue, type JsonValue } from '@entifix/core';\nimport { useCallback, useEffect } from 'react';\nimport { create } from 'zustand';\nimport { createJSONStorage, persist } from 'zustand/middleware';\n\nimport { makeIndexedDbStateStorage } from './idb-state-storage.js';\nimport { WORKSPACE_DB } from './tabs-state.js';\n\n/**\n * Per-address edit drafts, persisted to IndexedDB so an in-progress edit\n * survives a refresh. Keyed by the tab's `?tab=` param (its address), a draft is\n * whatever the editor needs to restore its fields; it exists until the user\n * saves (or discards). This is the \"continuous autosave\" seam — workspace-host\n * only, so a plain route stays ephemeral.\n *\n * **A draft is JSON round-trippable, period.** It is written through\n * `createJSONStorage`, so a class instance, an `EntityLink` or a `Date` does not\n * \"mostly survive\" — it comes back as something else, silently. {@link JsonValue}\n * is the compile-time half of that rule and {@link mergeDrafts} the runtime half.\n * Note that `UiPreferencesState`, the other persisted client store, writes\n * through IndexedDB's structured clone and *does* keep a `Date`; the two\n * contracts differ and must not be conflated.\n */\nexport interface DraftsState {\n  drafts: Record<string, JsonValue>;\n  setDraft(address: string, value: JsonValue): void;\n  clearDraft(address: string): void;\n}\n\nexport function persistedDrafts(\n  store: DraftsState,\n): Pick<DraftsState, 'drafts'> {\n  return { drafts: store.drafts };\n}\n\nconst DRAFTS_STORE = 'stores';\n\n/**\n * Bump when the *envelope* changes — how a draft is keyed or wrapped — and every\n * persisted draft is discarded on the next load.\n *\n * It cannot see a change to one entity's members, because a draft is opaque\n * here: this store holds `JsonValue`, and only the form that wrote one knows\n * which members it should have. That half is `restoreEntityDraft`, which layers\n * a restored draft over a freshly seeded one so a drifted member is dropped or\n * re-seeded rather than rendered.\n */\n// 2: a draft is keyed by the tab address, and that grammar changed with\n// ADR 0042 — so every persisted draft is filed under a key nothing will ask for.\nexport const DRAFTS_VERSION = 2;\n\nconst emptyDrafts: Pick<DraftsState, 'drafts'> = { drafts: {} };\n\n/**\n * Discard, never guess. A draft whose envelope this build does not understand is\n * an unfinished edit, not a record — losing it costs a retype, while migrating\n * it blind risks submitting values whose meaning has changed.\n *\n * Written out rather than left to zustand's default, which discards too but logs\n * `State loaded from storage couldn't be migrated since no migrate function was\n * provided` while doing it — an error message for a decision that was made on\n * purpose.\n */\nexport function migrateDrafts(): Pick<DraftsState, 'drafts'> {\n  return emptyDrafts;\n}\n\n/**\n * Restores only the entries that are actually JSON.\n *\n * The type above says what may be written; this is what happens when something\n * else was, by a build that predates the rule or by a `setDraft` reached through\n * a cast. Dropping the offending entry keeps one bad draft from taking the whole\n * workspace's drafts with it — and it is per entry rather than all-or-nothing\n * for that reason.\n */\nexport function mergeDrafts(\n  persistedState: unknown,\n  currentState: DraftsState,\n): DraftsState {\n  const restored = (persistedState as Partial<DraftsState> | undefined)?.drafts;\n  if (restored === null || typeof restored !== 'object') return currentState;\n\n  const drafts: Record<string, JsonValue> = {};\n  for (const [address, value] of Object.entries(restored)) {\n    if (isJsonValue(value)) drafts[address] = value;\n  }\n  return { ...currentState, drafts };\n}\n\nexport const useDraftsState = create<DraftsState>()(\n  persist(\n    set => ({\n      drafts: {},\n      setDraft: (address, value) =>\n        set(state => ({ drafts: { ...state.drafts, [address]: value } })),\n      clearDraft: address =>\n        set(state => {\n          if (!(address in state.drafts)) return state;\n          const { [address]: _removed, ...rest } = state.drafts;\n          return { drafts: rest };\n        }),\n    }),\n    {\n      // Replaced with a scoped name by `WorkspaceShell` before it rehydrates, so\n      // two accounts on one browser profile do not share drafts. This literal is\n      // only what an unscoped store would write, and nothing rehydrates without\n      // passing through that call.\n      name: 'drafts',\n      version: DRAFTS_VERSION,\n      migrate: migrateDrafts,\n      merge: mergeDrafts,\n      storage: createJSONStorage(() =>\n        makeIndexedDbStateStorage(WORKSPACE_DB, DRAFTS_STORE),\n      ),\n      partialize: persistedDrafts,\n      skipHydration: true,\n    },\n  ),\n);\n\n/**\n * Bind an editor to its persisted draft. Returns the current draft (restored\n * from IndexedDB on mount), a setter the editor calls as fields change, and a\n * clear for when the edit is committed.\n *\n * `TDraft` is constrained to {@link JsonValue}: an editor that wants to autosave\n * something a JSON round trip would not return is asking for the one thing this\n * store cannot do, and the compile error is the whole point of the constraint.\n *\n * One sharp edge, and the error message does not explain it: **declare a draft\n * type as a `type`, never an `interface`.** TypeScript gives an interface no\n * implicit index signature, so even `interface Draft { name: string }` — as JSON\n * as a value gets — fails the constraint with \"Index signature for type 'string'\n * is missing\". A `type` alias of the same shape passes.\n */\nexport function useDraft<TDraft extends JsonValue>(address: string) {\n  const draft = useDraftsState(\n    state => state.drafts[address] as TDraft | undefined,\n  );\n  const set = useDraftsState(state => state.setDraft);\n  const clear = useDraftsState(state => state.clearDraft);\n\n  useEffect(() => {\n    void useDraftsState.persist.rehydrate();\n  }, []);\n\n  const setDraft = useCallback(\n    (value: TDraft) => set(address, value),\n    [set, address],\n  );\n  const clearDraft = useCallback(() => clear(address), [clear, address]);\n\n  return { draft, setDraft, clearDraft };\n}\n"],"names":["isJsonValue","useCallback","useEffect","create","createJSONStorage","persist","makeIndexedDbStateStorage","WORKSPACE_DB","persistedDrafts","store","drafts","DRAFTS_STORE","DRAFTS_VERSION","emptyDrafts","migrateDrafts","mergeDrafts","persistedState","currentState","restored","address","value","Object","entries","useDraftsState","set","setDraft","state","clearDraft","_removed","rest","name","version","migrate","merge","storage","partialize","skipHydration","useDraft","draft","clear","rehydrate"],"mappings":"AAAA;;;;AAEA,SAASA,WAAW,QAAwB,gBAAgB;AAC5D,SAASC,WAAW,EAAEC,SAAS,QAAQ,QAAQ;AAC/C,SAASC,MAAM,QAAQ,UAAU;AACjC,SAASC,iBAAiB,EAAEC,OAAO,QAAQ,qBAAqB;AAEhE,SAASC,yBAAyB,QAAQ,yBAAyB;AACnE,SAASC,YAAY,QAAQ,kBAAkB;AAuB/C,OAAO,SAASC,gBACdC,KAAkB;IAElB,OAAO;QAAEC,QAAQD,MAAMC,MAAM;IAAC;AAChC;AAEA,MAAMC,eAAe;AAErB;;;;;;;;;CASC,GACD,wEAAwE;AACxE,iFAAiF;AACjF,OAAO,MAAMC,iBAAiB,EAAE;AAEhC,MAAMC,cAA2C;IAAEH,QAAQ,CAAC;AAAE;AAE9D;;;;;;;;;CASC,GACD,OAAO,SAASI;IACd,OAAOD;AACT;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASE,YACdC,cAAuB,EACvBC,YAAyB;IAEzB,MAAMC,WAAYF,kCAAD,AAACA,eAAqDN,MAAM;IAC7E,IAAIQ,aAAa,QAAQ,OAAOA,aAAa,UAAU,OAAOD;IAE9D,MAAMP,SAAoC,CAAC;IAC3C,KAAK,MAAM,CAACS,SAASC,MAAM,IAAIC,OAAOC,OAAO,CAACJ,UAAW;QACvD,IAAIlB,YAAYoB,QAAQV,MAAM,CAACS,QAAQ,GAAGC;IAC5C;IACA,OAAO,aAAKH;QAAcP;;AAC5B;AAEA,OAAO,MAAMa,iBAAiBpB,SAC5BE,QACEmB,CAAAA,MAAQ,CAAA;QACNd,QAAQ,CAAC;QACTe,UAAU,CAACN,SAASC,QAClBI,IAAIE,CAAAA,QAAU,CAAA;oBAAEhB,QAAQ,aAAKgB,MAAMhB,MAAM;wBAAE,CAACS,QAAQ,EAAEC;;gBAAQ,CAAA;QAChEO,YAAYR,CAAAA,UACVK,IAAIE,CAAAA;gBACF,IAAI,CAAEP,CAAAA,WAAWO,MAAMhB,MAAM,AAAD,GAAI,OAAOgB;gBACvC,MAAyCA,gBAAAA,MAAMhB,MAAM,EAA/C,EAAE,CAACS,QAAQ,EAAES,QAAQ,EAAW,GAAGF,eAATG,wCAASH;qCAAhCP;;gBACT,OAAO;oBAAET,QAAQmB;gBAAK;YACxB;IACJ,CAAA,GACA;IACE,2EAA2E;IAC3E,2EAA2E;IAC3E,0EAA0E;IAC1E,6BAA6B;IAC7BC,MAAM;IACNC,SAASnB;IACToB,SAASlB;IACTmB,OAAOlB;IACPmB,SAAS9B,kBAAkB,IACzBE,0BAA0BC,cAAcI;IAE1CwB,YAAY3B;IACZ4B,eAAe;AACjB,IAEF;AAEF;;;;;;;;;;;;;;CAcC,GACD,OAAO,SAASC,SAAmClB,OAAe;IAChE,MAAMmB,QAAQf,eACZG,CAAAA,QAASA,MAAMhB,MAAM,CAACS,QAAQ;IAEhC,MAAMK,MAAMD,eAAeG,CAAAA,QAASA,MAAMD,QAAQ;IAClD,MAAMc,QAAQhB,eAAeG,CAAAA,QAASA,MAAMC,UAAU;IAEtDzB,UAAU;QACR,KAAKqB,eAAelB,OAAO,CAACmC,SAAS;IACvC,GAAG,EAAE;IAEL,MAAMf,WAAWxB,YACf,CAACmB,QAAkBI,IAAIL,SAASC,QAChC;QAACI;QAAKL;KAAQ;IAEhB,MAAMQ,aAAa1B,YAAY,IAAMsC,MAAMpB,UAAU;QAACoB;QAAOpB;KAAQ;IAErE,OAAO;QAAEmB;QAAOb;QAAUE;IAAW;AACvC"}

package/dist/lib/workspace/entity-nav.d.ts

@@ -0,0 +1,26 @@
+import { type ReactNode } from 'react';
+/**
+ * Navigation intent, decoupled from the host. A page says "go to this list" or
+ * "open this entity"; the host decides how. In a route the destination is a URL
+ * push; in the workspace it is a tab open/focus. A page calls {@link useEntityNav}
+ * and never learns which host it is in.
+ */
+export interface EntityNav {
+    toList(entityKey: string): void;
+    toEntity(entityKey: string, id: string): void;
+}
+/** Route host: navigation is a canonical URL push under `/catalog`. */
+export declare function useRouteEntityNav(basePath?: string): EntityNav;
+/** Tab host: navigation opens or focuses a workspace tab. */
+export declare function useTabEntityNav(): EntityNav;
+export declare function EntityNavProvider({ value, children, }: {
+    value: EntityNav;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * The active {@link EntityNav}. Falls back to route navigation when no provider
+ * is mounted, so a page rendered as a plain route (its default host) navigates
+ * by URL without any wiring; the workspace wraps its tabs in a tab-nav provider.
+ */
+export declare function useEntityNav(): EntityNav;
+//# sourceMappingURL=entity-nav.d.ts.map

package/dist/lib/workspace/entity-nav.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-nav.d.ts","sourceRoot":"","sources":["../../../src/lib/workspace/entity-nav.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAiB,KAAK,SAAS,EAAuB,MAAM,OAAO,CAAC;AAI3E;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/C;AAID,uEAAuE;AACvE,wBAAgB,iBAAiB,CAAC,QAAQ,SAAa,GAAG,SAAS,CAUlE;AAED,6DAA6D;AAC7D,wBAAgB,eAAe,IAAI,SAAS,CAiB3C;AAED,wBAAgB,iBAAiB,CAAC,EAChC,KAAK,EACL,QAAQ,GACT,EAAE;IACD,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,EAAE,SAAS,CAAC;CACrB,+BAMA;AAED;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,SAAS,CAIxC"}

package/dist/lib/workspace/entity-nav.js

@@ -0,0 +1,56 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { screenAddress } from '@entifix/authz';
+import { useRouter } from 'next/navigation';
+import { createContext, useContext, useMemo } from 'react';
+import { useTabsState } from './tabs-state.js';
+const EntityNavContext = /*#__PURE__*/ createContext(null);
+/** Route host: navigation is a canonical URL push under `/catalog`. */ export function useRouteEntityNav(basePath = '/catalog') {
+    const router = useRouter();
+    return useMemo(()=>({
+            toList: (entityKey)=>router.push(`${basePath}/${entityKey}`),
+            toEntity: (entityKey, id)=>router.push(`${basePath}/${entityKey}/${id}`)
+        }), [
+        router,
+        basePath
+    ]);
+}
+/** Tab host: navigation opens or focuses a workspace tab. */ export function useTabEntityNav() {
+    const open = useTabsState((state)=>state.open);
+    return useMemo(()=>({
+            toList: (entityKey)=>open({
+                    param: screenAddress({
+                        type: 'master',
+                        key: entityKey
+                    }),
+                    title: entityKey
+                }),
+            toEntity: (entityKey, id)=>open({
+                    param: screenAddress({
+                        type: 'master',
+                        key: entityKey,
+                        id
+                    }),
+                    title: `${entityKey} #${id}`
+                })
+        }), [
+        open
+    ]);
+}
+export function EntityNavProvider({ value, children }) {
+    return /*#__PURE__*/ _jsx(EntityNavContext.Provider, {
+        value: value,
+        children: children
+    });
+}
+/**
+ * The active {@link EntityNav}. Falls back to route navigation when no provider
+ * is mounted, so a page rendered as a plain route (its default host) navigates
+ * by URL without any wiring; the workspace wraps its tabs in a tab-nav provider.
+ */ export function useEntityNav() {
+    const provided = useContext(EntityNavContext);
+    const routeNav = useRouteEntityNav();
+    return provided != null ? provided : routeNav;
+}
+
+//# sourceMappingURL=entity-nav.js.map

package/dist/lib/workspace/entity-nav.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/workspace/entity-nav.tsx"],"sourcesContent":["'use client';\n\nimport { screenAddress } from '@entifix/authz';\nimport { useRouter } from 'next/navigation';\nimport { createContext, type ReactNode, useContext, useMemo } from 'react';\n\nimport { useTabsState } from './tabs-state.js';\n\n/**\n * Navigation intent, decoupled from the host. A page says \"go to this list\" or\n * \"open this entity\"; the host decides how. In a route the destination is a URL\n * push; in the workspace it is a tab open/focus. A page calls {@link useEntityNav}\n * and never learns which host it is in.\n */\nexport interface EntityNav {\n  toList(entityKey: string): void;\n  toEntity(entityKey: string, id: string): void;\n}\n\nconst EntityNavContext = createContext<EntityNav | null>(null);\n\n/** Route host: navigation is a canonical URL push under `/catalog`. */\nexport function useRouteEntityNav(basePath = '/catalog'): EntityNav {\n  const router = useRouter();\n  return useMemo(\n    () => ({\n      toList: entityKey => router.push(`${basePath}/${entityKey}`),\n      toEntity: (entityKey, id) =>\n        router.push(`${basePath}/${entityKey}/${id}`),\n    }),\n    [router, basePath],\n  );\n}\n\n/** Tab host: navigation opens or focuses a workspace tab. */\nexport function useTabEntityNav(): EntityNav {\n  const open = useTabsState(state => state.open);\n  return useMemo(\n    () => ({\n      toList: entityKey =>\n        open({\n          param: screenAddress({ type: 'master', key: entityKey }),\n          title: entityKey,\n        }),\n      toEntity: (entityKey, id) =>\n        open({\n          param: screenAddress({ type: 'master', key: entityKey, id }),\n          title: `${entityKey} #${id}`,\n        }),\n    }),\n    [open],\n  );\n}\n\nexport function EntityNavProvider({\n  value,\n  children,\n}: {\n  value: EntityNav;\n  children: ReactNode;\n}) {\n  return (\n    <EntityNavContext.Provider value={value}>\n      {children}\n    </EntityNavContext.Provider>\n  );\n}\n\n/**\n * The active {@link EntityNav}. Falls back to route navigation when no provider\n * is mounted, so a page rendered as a plain route (its default host) navigates\n * by URL without any wiring; the workspace wraps its tabs in a tab-nav provider.\n */\nexport function useEntityNav(): EntityNav {\n  const provided = useContext(EntityNavContext);\n  const routeNav = useRouteEntityNav();\n  return provided ?? routeNav;\n}\n"],"names":["screenAddress","useRouter","createContext","useContext","useMemo","useTabsState","EntityNavContext","useRouteEntityNav","basePath","router","toList","entityKey","push","toEntity","id","useTabEntityNav","open","state","param","type","key","title","EntityNavProvider","value","children","Provider","useEntityNav","provided","routeNav"],"mappings":"AAAA;;AAEA,SAASA,aAAa,QAAQ,iBAAiB;AAC/C,SAASC,SAAS,QAAQ,kBAAkB;AAC5C,SAASC,aAAa,EAAkBC,UAAU,EAAEC,OAAO,QAAQ,QAAQ;AAE3E,SAASC,YAAY,QAAQ,kBAAkB;AAa/C,MAAMC,iCAAmBJ,cAAgC;AAEzD,qEAAqE,GACrE,OAAO,SAASK,kBAAkBC,WAAW,UAAU;IACrD,MAAMC,SAASR;IACf,OAAOG,QACL,IAAO,CAAA;YACLM,QAAQC,CAAAA,YAAaF,OAAOG,IAAI,CAAC,GAAGJ,SAAS,CAAC,EAAEG,WAAW;YAC3DE,UAAU,CAACF,WAAWG,KACpBL,OAAOG,IAAI,CAAC,GAAGJ,SAAS,CAAC,EAAEG,UAAU,CAAC,EAAEG,IAAI;QAChD,CAAA,GACA;QAACL;QAAQD;KAAS;AAEtB;AAEA,2DAA2D,GAC3D,OAAO,SAASO;IACd,MAAMC,OAAOX,aAAaY,CAAAA,QAASA,MAAMD,IAAI;IAC7C,OAAOZ,QACL,IAAO,CAAA;YACLM,QAAQC,CAAAA,YACNK,KAAK;oBACHE,OAAOlB,cAAc;wBAAEmB,MAAM;wBAAUC,KAAKT;oBAAU;oBACtDU,OAAOV;gBACT;YACFE,UAAU,CAACF,WAAWG,KACpBE,KAAK;oBACHE,OAAOlB,cAAc;wBAAEmB,MAAM;wBAAUC,KAAKT;wBAAWG;oBAAG;oBAC1DO,OAAO,GAAGV,UAAU,EAAE,EAAEG,IAAI;gBAC9B;QACJ,CAAA,GACA;QAACE;KAAK;AAEV;AAEA,OAAO,SAASM,kBAAkB,EAChCC,KAAK,EACLC,QAAQ,EAIT;IACC,qBACE,KAAClB,iBAAiBmB,QAAQ;QAACF,OAAOA;kBAC/BC;;AAGP;AAEA;;;;CAIC,GACD,OAAO,SAASE;IACd,MAAMC,WAAWxB,WAAWG;IAC5B,MAAMsB,WAAWrB;IACjB,OAAOoB,mBAAAA,WAAYC;AACrB"}

package/dist/lib/workspace/entity-tab-kind.d.ts

@@ -0,0 +1,51 @@
+import { type ScreenType } from '@entifix/authz';
+import type { ReactNode } from 'react';
+import type { TabKind } from './tab-kind.js';
+/** One list a workspace may open — the collection half of a screen. */
+export interface EntityTabList {
+    /** The tab caption's catalog key. `@entity({ pluralKey })` for a generated screen. */
+    readonly titleKey: string;
+    render(): ReactNode;
+}
+/** One record a workspace may open — the same screen, with an id. */
+export interface EntityTabRecord {
+    /** The tab caption's catalog key. `@entity({ labelKey })` for a generated screen. */
+    readonly labelKey: string;
+    render(id: string): ReactNode;
+}
+export interface EntityTabScreens {
+    readonly lists: Record<string, EntityTabList>;
+    readonly records: Record<string, EntityTabRecord>;
+}
+/**
+ * An entity tab kind: `<type>:<key>` for a list, `<type>:<key>:<id>` for one
+ * record.
+ *
+ * **The list and the record are not different kinds.** They are the same screen
+ * with and without a record, which is exactly what the optional id in the
+ * payload says — three kinds (`catalog:`, `entity:`, `system:`) collapsed into
+ * one for that reason, and the prefix names the *taxonomy* now
+ * ([ADR 0042](../../../../../../../docs/adr/0042-the-workspace-address-is-the-taxonomy-serialized.md)).
+ *
+ * A factory over the {@link ScreenType} rather than a constant, and that is the
+ * whole of what makes an Operaciones screen addressable. It was written inline
+ * in back-office-app as a `masterKind`, so `master:` was the only entity
+ * address any host could resolve and `operation:` matched nothing at all — a
+ * second copy of this parser beside it is exactly the drift the registry was
+ * consolidated to stop, and the two would have had to agree about a grammar
+ * neither owns.
+ *
+ * Which screens a host offers stays the host's decision — a second host
+ * mounting the same shells may want a different set — so the screens arrive as
+ * an argument. What no longer varies is how one is addressed.
+ *
+ * `render` takes the id rather than a component, so the caller decides what
+ * hosting a record means: in a workspace that is an editor wired to an
+ * address-keyed autosaved draft, and the address it keys on has to carry this
+ * same `type`.
+ */
+export declare function entityTabKind(type: ScreenType, screens: EntityTabScreens): TabKind<{
+    key: string;
+    id?: string;
+}>;
+//# sourceMappingURL=entity-tab-kind.d.ts.map

package/dist/lib/workspace/entity-tab-kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-tab-kind.d.ts","sourceRoot":"","sources":["../../../src/lib/workspace/entity-tab-kind.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,uEAAuE;AACvE,MAAM,WAAW,aAAa;IAC5B,sFAAsF;IACtF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,MAAM,IAAI,SAAS,CAAC;CACrB;AAED,qEAAqE;AACrE,MAAM,WAAW,eAAe;IAC9B,qFAAqF;IACrF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CACnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA0BvC"}

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

@@ -0,0 +1,47 @@
+'use client';
+import { parseScreenPayload } from '@entifix/authz';
+/**
+ * An entity tab kind: `<type>:<key>` for a list, `<type>:<key>:<id>` for one
+ * record.
+ *
+ * **The list and the record are not different kinds.** They are the same screen
+ * with and without a record, which is exactly what the optional id in the
+ * payload says — three kinds (`catalog:`, `entity:`, `system:`) collapsed into
+ * one for that reason, and the prefix names the *taxonomy* now
+ * ([ADR 0042](../../../../../../../docs/adr/0042-the-workspace-address-is-the-taxonomy-serialized.md)).
+ *
+ * A factory over the {@link ScreenType} rather than a constant, and that is the
+ * whole of what makes an Operaciones screen addressable. It was written inline
+ * in back-office-app as a `masterKind`, so `master:` was the only entity
+ * address any host could resolve and `operation:` matched nothing at all — a
+ * second copy of this parser beside it is exactly the drift the registry was
+ * consolidated to stop, and the two would have had to agree about a grammar
+ * neither owns.
+ *
+ * Which screens a host offers stays the host's decision — a second host
+ * mounting the same shells may want a different set — so the screens arrive as
+ * an argument. What no longer varies is how one is addressed.
+ *
+ * `render` takes the id rather than a component, so the caller decides what
+ * hosting a record means: in a workspace that is an editor wired to an
+ * address-keyed autosaved draft, and the address it keys on has to carry this
+ * same `type`.
+ */ export function entityTabKind(type, screens) {
+    return {
+        kind: type,
+        match: (payload)=>{
+            const parsed = parseScreenPayload(payload);
+            if (parsed === null) return null;
+            // A key is valid for the half it names: a record address for a screen
+            // with a list and no record editor resolves to nothing, and the workspace
+            // answers with its fallback rather than rendering an empty editor.
+            const known = parsed.id === undefined ? parsed.key in screens.lists : parsed.key in screens.records;
+            return known ? parsed : null;
+        },
+        toParam: (addr)=>addr.id === undefined ? addr.key : `${addr.key}:${addr.id}`,
+        title: (addr, translate)=>addr.id === undefined ? translate(screens.lists[addr.key].titleKey) : `${translate(screens.records[addr.key].labelKey)} #${addr.id}`,
+        render: (addr)=>addr.id === undefined ? screens.lists[addr.key].render() : screens.records[addr.key].render(addr.id)
+    };
+}
+
+//# sourceMappingURL=entity-tab-kind.js.map