@endora-commerce/admin-kit 0.0.0-stage → 0.100.0

package/dist/zones/AdminContributionsProvider.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * The seam that carries the admin's module registry into the kit (feature 091,
+ * P4a; Z6).
+ *
+ * The renderer is the kit's and not the admin application's, because a **host**
+ * screen becomes a package: `catalog` hosts three zones and moves into
+ * `packages/modules/catalog`, at which point `admin/src/lib/module-registry` is
+ * unreachable to it. Routes and nav have no such problem — their one consumer
+ * each is the application itself, for ever — which is why `registryRoutes()`
+ * and `registryNavFor()` stay where they are and there is no
+ * `registryZonesFor()` beside them.
+ *
+ * The registry itself stays the application's: it *is* module knowledge, and
+ * `admin-kit-surface.md` R6 refuses module knowledge in the kit. So the kit
+ * publishes a provider and holds no list — the entries arrive as a prop, from
+ * the one place that has them.
+ *
+ * **Nothing here filters.** An operator's activation flip must take effect
+ * without a rebuild (Principle XVII item 5, D-67/D-68 pointed at the frontend),
+ * so presence is decided at enumeration in {@link useAdminZone} and never in
+ * the registry or in this provider. The provider answers *"what could be
+ * here"*.
+ */
+import { createContext, useContext, useMemo } from 'react';
+/**
+ * Flattened contributions, in declaration order.
+ *
+ * `null` is the "no provider mounted" state and is distinct from "the provider
+ * is mounted and every module contributes nothing": {@link useAdminZone} refuses
+ * the first and returns an empty list for the second, because a host screen
+ * rendering a zone outside the provider is a wiring defect and reporting it as
+ * *"nobody contributed"* is the silent answer this estate refuses everywhere
+ * else.
+ */
+const AdminContributionsContext = createContext(null);
+/** Raised when a zone is rendered outside {@link AdminContributionsProvider}. */
+export class AdminContributionsUnavailableError extends Error {
+    name = 'AdminContributionsUnavailableError';
+}
+/** Mounted once by the admin application, with its generated registry. */
+export function AdminContributionsProvider({ entries, children, }) {
+    const flattened = useMemo(() => entries.flatMap((entry) => (entry.contributions.zones ?? []).map((zone) => ({ ...zone, module: entry.moduleId }))), [entries]);
+    return (_jsx(AdminContributionsContext.Provider, { value: flattened, children: children }));
+}
+/**
+ * Every contribution the provider carries, unfiltered and unordered.
+ *
+ * Internal to the `./zones` subpath: the filtering and the ordering are
+ * {@link useAdminZone}'s, and a second consumer of the raw list is a second
+ * place the presence rule could be forgotten.
+ */
+export function useAdminContributions() {
+    const value = useContext(AdminContributionsContext);
+    if (value === null) {
+        throw new AdminContributionsUnavailableError('A zone was rendered outside <AdminContributionsProvider>. The admin application ' +
+            'mounts it once, with MODULE_ADMIN_CONTRIBUTIONS; a test rendering a host screen ' +
+            'mounts it with the contributions under assertion. Reporting "nobody contributed" ' +
+            'here would make a wiring defect indistinguishable from an empty registry.');
+    }
+    return value;
+}
+//# sourceMappingURL=AdminContributionsProvider.js.map

package/dist/zones/AdminContributionsProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdminContributionsProvider.js","sourceRoot":"","sources":["../../src/zones/AdminContributionsProvider.tsx"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,OAAO,EAAkB,MAAM,OAAO,CAAC;AAqB3E;;;;;;;;;GASG;AACH,MAAM,yBAAyB,GAAG,aAAa,CAA0C,IAAI,CAAC,CAAC;AAE/F,iFAAiF;AACjF,MAAM,OAAO,kCAAmC,SAAQ,KAAK;IACzC,IAAI,GAAG,oCAAoC,CAAC;CAC/D;AAiBD,0EAA0E;AAC1E,MAAM,UAAU,0BAA0B,CAAC,EACzC,OAAO,EACP,QAAQ,GACwB;IAChC,MAAM,SAAS,GAAG,OAAO,CACvB,GAAqC,EAAE,CACrC,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CACxB,CAAC,KAAK,CAAC,aAAa,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,GAAG,CACnC,CAAC,IAAI,EAAyB,EAAE,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CACvE,CACF,EACH,CAAC,OAAO,CAAC,CACV,CAAC;IACF,OAAO,CACL,KAAC,yBAAyB,CAAC,QAAQ,IAAC,KAAK,EAAE,SAAS,YACjD,QAAQ,GAC0B,CACtC,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB;IACnC,MAAM,KAAK,GAAG,UAAU,CAAC,yBAAyB,CAAC,CAAC;IACpD,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACnB,MAAM,IAAI,kCAAkC,CAC1C,kFAAkF;YAChF,kFAAkF;YAClF,mFAAmF;YACnF,2EAA2E,CAC9E,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/zones/AdminZone.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The common case: render every contribution to this mount, in order (feature
+ * 091, P4a; Z6/Z8).
+ *
+ * `useAdminZone` is the primitive and stays exported, because a host whose zone
+ * is not a stack of components needs the list rather than the rendering — a tab
+ * strip counts its contributions, and `<RouteTabsZone>` is built on the hook,
+ * not on this.
+ *
+ * Generic on the literal zone name, so `props` is checked against
+ * `AdminZonePropsMap` at the host's end (Z3). That is one of the two ends the
+ * map holds; the contributor's is `zoneComponent()` on `./contributions`.
+ */
+import { type ReactNode } from 'react';
+import type { AdminZoneName, AdminZoneProps } from '@endora-commerce/contracts';
+export interface AdminZoneRenderProps<Z extends AdminZoneName> {
+    readonly name: Z;
+    readonly props: AdminZoneProps<Z>;
+}
+/**
+ * Render the zone `name` at this mount.
+ *
+ * ```tsx
+ * <AdminZone name="product.editor.field.after" props={{ productId, fieldPath: 'name', languageCodes: LOCALES }} />
+ * ```
+ *
+ * The name is a **string literal**, always (Z7).
+ */
+export declare function AdminZone<Z extends AdminZoneName>({ name, props, }: AdminZoneRenderProps<Z>): ReactNode;
+//# sourceMappingURL=AdminZone.d.ts.map

package/dist/zones/AdminZone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdminZone.d.ts","sourceRoot":"","sources":["../../src/zones/AdminZone.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAA+C,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACpF,OAAO,KAAK,EAEV,aAAa,EACb,cAAc,EACf,MAAM,4BAA4B,CAAC;AAmCpC,MAAM,WAAW,oBAAoB,CAAC,CAAC,SAAS,aAAa;IAC3D,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;CACnC;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,aAAa,EAAE,EACjD,IAAI,EACJ,KAAK,GACN,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAAG,SAAS,CA+BrC"}

package/dist/zones/AdminZone.js

@@ -0,0 +1,59 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * The common case: render every contribution to this mount, in order (feature
+ * 091, P4a; Z6/Z8).
+ *
+ * `useAdminZone` is the primitive and stays exported, because a host whose zone
+ * is not a stack of components needs the list rather than the rendering — a tab
+ * strip counts its contributions, and `<RouteTabsZone>` is built on the hook,
+ * not on this.
+ *
+ * Generic on the literal zone name, so `props` is checked against
+ * `AdminZonePropsMap` at the host's end (Z3). That is one of the two ends the
+ * map holds; the contributor's is `zoneComponent()` on `./contributions`.
+ */
+import { Suspense, lazy, useMemo } from 'react';
+import { useAdminZone } from './use-admin-zone.js';
+import { ZoneErrorBoundary } from './ZoneErrorBoundary.js';
+const lazyByFactory = new WeakMap();
+function lazyComponentFor(load) {
+    const known = lazyByFactory.get(load);
+    if (known !== undefined)
+        return known;
+    // The registry's factory is `{ default: unknown }` by construction — see the
+    // note on `AdminComponentFactory` — and the assertion here is the courier's
+    // end of the map, not a hole: `zoneComponent()` constrained the contributor's
+    // export and this component's generic constrains the host's props against the
+    // same `AdminZonePropsMap`.
+    const built = lazy(async () => ({
+        default: (await load()).default,
+    }));
+    lazyByFactory.set(load, built);
+    return built;
+}
+/**
+ * Render the zone `name` at this mount.
+ *
+ * ```tsx
+ * <AdminZone name="product.editor.field.after" props={{ productId, fieldPath: 'name', languageCodes: LOCALES }} />
+ * ```
+ *
+ * The name is a **string literal**, always (Z7).
+ */
+export function AdminZone({ name, props, }) {
+    const contributions = useAdminZone(name, props);
+    // One entry per contribution, so a contributor added or removed by a presence
+    // flip does not rebuild the others' component types.
+    const rendered = useMemo(() => contributions.map((contribution, index) => ({
+        // A module may declare two contributions to one zone, so the key is
+        // the module **and** its position in the ordered list, never the module
+        // alone: two children under one key is a silent remount in React.
+        key: `${contribution.module}:${index}`,
+        module: contribution.module,
+        Component: lazyComponentFor(contribution.component),
+    })), [contributions]);
+    if (rendered.length === 0)
+        return null;
+    return (_jsx(_Fragment, { children: rendered.map((entry) => (_jsx(ZoneErrorBoundary, { module: entry.module, zone: name, children: _jsx(Suspense, { fallback: null, children: _jsx(entry.Component, { ...props }) }) }, entry.key))) }));
+}
+//# sourceMappingURL=AdminZone.js.map

package/dist/zones/AdminZone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdminZone.js","sourceRoot":"","sources":["../../src/zones/AdminZone.tsx"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAsC,MAAM,OAAO,CAAC;AAOpF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAe3D,MAAM,aAAa,GAAG,IAAI,OAAO,EAA4C,CAAC;AAE9E,SAAS,gBAAgB,CAAC,IAA2B;IACnD,MAAM,KAAK,GAAG,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACtC,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IACtC,6EAA6E;IAC7E,4EAA4E;IAC5E,8EAA8E;IAC9E,8EAA8E;IAC9E,4BAA4B;IAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;QAC9B,OAAO,EAAE,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,OAA4B;KACrD,CAAC,CAAC,CAAC;IACJ,aAAa,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC/B,OAAO,KAAK,CAAC;AACf,CAAC;AAOD;;;;;;;;GAQG;AACH,MAAM,UAAU,SAAS,CAA0B,EACjD,IAAI,EACJ,KAAK,GACmB;IACxB,MAAM,aAAa,GAAG,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAChD,8EAA8E;IAC9E,qDAAqD;IACrD,MAAM,QAAQ,GAAG,OAAO,CACtB,GAAG,EAAE,CACH,aAAa,CAAC,GAAG,CAAC,CAAC,YAAY,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;QAC1C,oEAAoE;QACpE,wEAAwE;QACxE,kEAAkE;QAClE,GAAG,EAAE,GAAG,YAAY,CAAC,MAAM,IAAI,KAAK,EAAE;QACtC,MAAM,EAAE,YAAY,CAAC,MAAM;QAC3B,SAAS,EAAE,gBAAgB,CAAC,YAAY,CAAC,SAAS,CAAC;KACpD,CAAC,CAAC,EACL,CAAC,aAAa,CAAC,CAChB,CAAC;IACF,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACvC,OAAO,CACL,4BACG,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CACvB,KAAC,iBAAiB,IAAiB,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,YAIjE,KAAC,QAAQ,IAAC,QAAQ,EAAE,IAAI,YACtB,KAAC,KAAK,CAAC,SAAS,OAAM,KAA4C,GAAI,GAC7D,IANW,KAAK,CAAC,GAAG,CAOb,CACrB,CAAC,GACD,CACJ,CAAC;AACJ,CAAC"}

package/dist/zones/RouteTabsZone.d.ts

@@ -0,0 +1,62 @@
+/**
+ * A zone rendered as a **tab strip** (feature 091, P4d; Z15's mechanism half).
+ *
+ * `<AdminZone>` renders a zone's contributions as a stack, which is the common
+ * case and covers every member but this one. A strip is different in exactly
+ * one way, and it is the way that made `OrderEntryTabs` a host component nobody
+ * could publish: **the strip decides whether it exists from how many
+ * contributions there are.** One tab is not a choice, so a strip with one tab
+ * is worse than no strip — it tells the operator there is somewhere else to go
+ * and then does not offer it.
+ *
+ * `useAdminZone` has already applied both presence axes and each contributor's
+ * permission (§4), so counting what it returns is counting the tabs the
+ * operator would actually see. That is the whole of *"fewer than two tabs is
+ * not a choice"*, expressed as arithmetic over the hook rather than as a module
+ * id a host has to know: `admin/src/components/OrderEntryTabs.tsx` used to
+ * write the same rule with `orders` and `quick_order` spelled into it.
+ *
+ * ## Why the minimum is a constant and not a prop
+ *
+ * Two is a property of *tab strips*, not of this zone: a strip offers a choice
+ * between siblings, and a choice needs two. A `minimum` prop would let a host
+ * ask for a one-tab strip, which is the thing the rule refuses. If a strip ever
+ * genuinely needs a different floor, the answer is a second renderer with its
+ * own reason, not a number the caller picks.
+ *
+ * ## What it delegates, and why that matters
+ *
+ * The contributions themselves go through `<AdminZone>` — same lazy-component
+ * cache, same `ZoneErrorBoundary` per contributor, same `Suspense`, same order.
+ * The strip supplies only the chrome. So a contributed tab that throws takes
+ * itself out of the strip and leaves the others (Z8), and a strip whose chunks
+ * are still in flight renders an empty `tablist` for a moment rather than
+ * pushing the host's content around. The **count** is known before any chunk is
+ * requested, which is what keeps the "is there a choice at all" decision
+ * immediate.
+ *
+ * A contributed tab renders `RouteTabLink` from `@endora-commerce/admin-kit/ui`;
+ * its own doc block records the one thing a contributed tab cannot do that
+ * `RouteTabs` can.
+ */
+import type { ReactNode } from 'react';
+import type { AdminZoneName, AdminZoneProps } from '@endora-commerce/contracts';
+export interface RouteTabsZoneProps<Z extends AdminZoneName> {
+    readonly name: Z;
+    readonly props: AdminZoneProps<Z>;
+    readonly className?: string;
+}
+/**
+ * Render the zone `name` as a tab strip, or nothing at all when fewer than two
+ * contributions survive presence and permission.
+ *
+ * ```tsx
+ * <RouteTabsZone name="order.entry.tabs" props={{}} className="mb-4" />
+ * ```
+ *
+ * The name is a **string literal**, always (Z7) — `check:admin-zones` reads
+ * this tag beside `<AdminZone>` and reports a computed one rather than skipping
+ * it.
+ */
+export declare function RouteTabsZone<Z extends AdminZoneName>({ name, props, className, }: RouteTabsZoneProps<Z>): ReactNode;
+//# sourceMappingURL=RouteTabsZone.d.ts.map

package/dist/zones/RouteTabsZone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouteTabsZone.d.ts","sourceRoot":"","sources":["../../src/zones/RouteTabsZone.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAShF,MAAM,WAAW,kBAAkB,CAAC,CAAC,SAAS,aAAa;IACzD,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IAClC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,aAAa,EAAE,EACrD,IAAI,EACJ,KAAK,EACL,SAAS,GACV,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,SAAS,CAUnC"}

package/dist/zones/RouteTabsZone.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from '../lib/utils.js';
+import { AdminZone } from './AdminZone.js';
+import { useAdminZone } from './use-admin-zone.js';
+/** A strip needs a choice, and a choice needs two. */
+const MINIMUM_TABS = 2;
+/**
+ * Render the zone `name` as a tab strip, or nothing at all when fewer than two
+ * contributions survive presence and permission.
+ *
+ * ```tsx
+ * <RouteTabsZone name="order.entry.tabs" props={{}} className="mb-4" />
+ * ```
+ *
+ * The name is a **string literal**, always (Z7) — `check:admin-zones` reads
+ * this tag beside `<AdminZone>` and reports a computed one rather than skipping
+ * it.
+ */
+export function RouteTabsZone({ name, props, className, }) {
+    const tabs = useAdminZone(name, props);
+    if (tabs.length < MINIMUM_TABS)
+        return null;
+    return (_jsx("div", { className: cn('b2b-tabs-scroll', className), children: _jsx("div", { className: "b2b-tabs", role: "tablist", children: _jsx(AdminZone, { name: name, props: props }) }) }));
+}
+//# sourceMappingURL=RouteTabsZone.js.map

package/dist/zones/RouteTabsZone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouteTabsZone.js","sourceRoot":"","sources":["../../src/zones/RouteTabsZone.tsx"],"names":[],"mappings":";AA4CA,OAAO,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD,sDAAsD;AACtD,MAAM,YAAY,GAAG,CAAC,CAAC;AAQvB;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,aAAa,CAA0B,EACrD,IAAI,EACJ,KAAK,EACL,SAAS,GACa;IACtB,MAAM,IAAI,GAAG,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACvC,IAAI,IAAI,CAAC,MAAM,GAAG,YAAY;QAAE,OAAO,IAAI,CAAC;IAC5C,OAAO,CACL,cAAK,SAAS,EAAE,EAAE,CAAC,iBAAiB,EAAE,SAAS,CAAC,YAC9C,cAAK,SAAS,EAAC,UAAU,EAAC,IAAI,EAAC,SAAS,YACtC,KAAC,SAAS,IAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,GAAI,GACnC,GACF,CACP,CAAC;AACJ,CAAC"}

package/dist/zones/ZoneErrorBoundary.d.ts

@@ -0,0 +1,36 @@
+/**
+ * One contributed component's blast radius (feature 091, P4a; Z8).
+ *
+ * A zone contribution is an **addition**. A third-party module's exception must
+ * not white-screen the product editor, so each contribution is wrapped
+ * separately: one contributor throwing leaves the others, and the host, alone.
+ *
+ * **This is not the defensive `catch` `check:port-catches` refuses.** That rule
+ * is about swallowing a `ModuleDisabledError` at a seam, where the swallow
+ * turns fail-closed into fail-open. Here there is no presence question inside
+ * the boundary at all: presence was decided at enumeration, before the factory
+ * was called (`use-admin-zone.ts` step 3), so there is nothing about presence
+ * for this boundary to hide.
+ *
+ * It logs once — naming the module and the zone, because a stack trace from a
+ * lazily loaded chunk names neither — renders nothing in production, and
+ * renders an inline marker under `import.meta.env.DEV` so a contributor
+ * developing against a host screen sees the failure rather than a gap.
+ */
+import { Component, type ErrorInfo, type ReactNode } from 'react';
+export interface ZoneErrorBoundaryProps {
+    readonly module: string;
+    readonly zone: string;
+    readonly children: ReactNode;
+}
+interface ZoneErrorBoundaryState {
+    readonly failed: boolean;
+}
+export declare class ZoneErrorBoundary extends Component<ZoneErrorBoundaryProps, ZoneErrorBoundaryState> {
+    state: ZoneErrorBoundaryState;
+    static getDerivedStateFromError(): ZoneErrorBoundaryState;
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    render(): ReactNode;
+}
+export {};
+//# sourceMappingURL=ZoneErrorBoundary.d.ts.map

package/dist/zones/ZoneErrorBoundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZoneErrorBoundary.d.ts","sourceRoot":"","sources":["../../src/zones/ZoneErrorBoundary.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,SAAS,EAAE,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAElE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;CAC9B;AAED,UAAU,sBAAsB;IAC9B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED,qBAAa,iBAAkB,SAAQ,SAAS,CAAC,sBAAsB,EAAE,sBAAsB,CAAC;IACrF,KAAK,EAAE,sBAAsB,CAAqB;IAE3D,MAAM,CAAC,wBAAwB,IAAI,sBAAsB;IAIhD,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI;IAaxD,MAAM,IAAI,SAAS;CAe7B"}

package/dist/zones/ZoneErrorBoundary.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * One contributed component's blast radius (feature 091, P4a; Z8).
+ *
+ * A zone contribution is an **addition**. A third-party module's exception must
+ * not white-screen the product editor, so each contribution is wrapped
+ * separately: one contributor throwing leaves the others, and the host, alone.
+ *
+ * **This is not the defensive `catch` `check:port-catches` refuses.** That rule
+ * is about swallowing a `ModuleDisabledError` at a seam, where the swallow
+ * turns fail-closed into fail-open. Here there is no presence question inside
+ * the boundary at all: presence was decided at enumeration, before the factory
+ * was called (`use-admin-zone.ts` step 3), so there is nothing about presence
+ * for this boundary to hide.
+ *
+ * It logs once — naming the module and the zone, because a stack trace from a
+ * lazily loaded chunk names neither — renders nothing in production, and
+ * renders an inline marker under `import.meta.env.DEV` so a contributor
+ * developing against a host screen sees the failure rather than a gap.
+ */
+import { Component } from 'react';
+export class ZoneErrorBoundary extends Component {
+    state = { failed: false };
+    static getDerivedStateFromError() {
+        return { failed: true };
+    }
+    componentDidCatch(error, info) {
+        // Once, and naming both ends of the contribution: `error.stack` points into
+        // a split chunk, which tells a reader neither which module shipped it nor
+        // which of that module's contributions was rendering.
+        console.error(`[admin-zone] '${this.props.module}' threw while rendering the ` +
+            `'${this.props.zone}' zone. The host screen is unaffected; this contribution ` +
+            'renders nothing.', error, info.componentStack);
+    }
+    render() {
+        if (!this.state.failed)
+            return this.props.children;
+        if (import.meta.env.DEV) {
+            return (_jsx("span", { role: "status", className: "text-xs text-destructive", "data-admin-zone-error": this.props.zone, children: `${this.props.module} failed to render here — see the console.` }));
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=ZoneErrorBoundary.js.map

package/dist/zones/ZoneErrorBoundary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZoneErrorBoundary.js","sourceRoot":"","sources":["../../src/zones/ZoneErrorBoundary.tsx"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,SAAS,EAAkC,MAAM,OAAO,CAAC;AAYlE,MAAM,OAAO,iBAAkB,SAAQ,SAAyD;IACrF,KAAK,GAA2B,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAE3D,MAAM,CAAC,wBAAwB;QAC7B,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IAC1B,CAAC;IAEQ,iBAAiB,CAAC,KAAc,EAAE,IAAe;QACxD,4EAA4E;QAC5E,0EAA0E;QAC1E,sDAAsD;QACtD,OAAO,CAAC,KAAK,CACX,iBAAiB,IAAI,CAAC,KAAK,CAAC,MAAM,8BAA8B;YAC9D,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,2DAA2D;YAC9E,kBAAkB,EACpB,KAAK,EACL,IAAI,CAAC,cAAc,CACpB,CAAC;IACJ,CAAC;IAEQ,MAAM;QACb,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;QACnD,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;YACxB,OAAO,CACL,eACE,IAAI,EAAC,QAAQ,EACb,SAAS,EAAC,0BAA0B,2BACb,IAAI,CAAC,KAAK,CAAC,IAAI,YAErC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,2CAA2C,GAC3D,CACR,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF"}

package/dist/zones/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `@endora-commerce/admin-kit/zones` — the **host's** side of a zone (feature
+ * 091, P4a; Z6).
+ *
+ * `AdminContributionsProvider` is mounted once by
+ * the admin application with its generated registry; `useAdminZone(name, props)`
+ * is the primitive — the visible, matched, ordered contributions for one mount;
+ * `<AdminZone name props />` is the common case, rendering them all with an
+ * error boundary and a `Suspense` each; `<RouteTabsZone name props />` is the
+ * one place a zone is a **tab strip**, where the count decides whether the
+ * strip exists at all (feature 091, P4d).
+ *
+ * **A separate subpath from `./contributions`, and the split is deliberate.**
+ * `./contributions` is the contributor's side and is data-only — a module's
+ * `src/admin/index.ts` imports it — while this subpath renders React. One
+ * subpath would let a declaration file import a component, which R2 of
+ * `admin-contribution.md` exists to prevent.
+ *
+ * The barrel is **explicit and holds no `export *`**, per
+ * `admin-kit-surface.md` R2.
+ */
+export { AdminZone } from './AdminZone.js';
+export type { AdminZoneRenderProps } from './AdminZone.js';
+export { RouteTabsZone } from './RouteTabsZone.js';
+export type { RouteTabsZoneProps } from './RouteTabsZone.js';
+export { AdminContributionsProvider, AdminContributionsUnavailableError, useAdminContributions, } from './AdminContributionsProvider.js';
+export type { AdminContributionsProviderProps, AdminZoneRegistryEntry, OwnedZoneContribution, } from './AdminContributionsProvider.js';
+export { matchesZoneProps, selectZoneContributions, useAdminZone } from './use-admin-zone.js';
+export { ZoneErrorBoundary } from './ZoneErrorBoundary.js';
+export type { ZoneErrorBoundaryProps } from './ZoneErrorBoundary.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/zones/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/zones/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,YAAY,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EACL,0BAA0B,EAC1B,kCAAkC,EAClC,qBAAqB,GACtB,MAAM,iCAAiC,CAAC;AACzC,YAAY,EACV,+BAA+B,EAC/B,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC9F,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,YAAY,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/zones/index.js

@@ -0,0 +1,27 @@
+/**
+ * `@endora-commerce/admin-kit/zones` — the **host's** side of a zone (feature
+ * 091, P4a; Z6).
+ *
+ * `AdminContributionsProvider` is mounted once by
+ * the admin application with its generated registry; `useAdminZone(name, props)`
+ * is the primitive — the visible, matched, ordered contributions for one mount;
+ * `<AdminZone name props />` is the common case, rendering them all with an
+ * error boundary and a `Suspense` each; `<RouteTabsZone name props />` is the
+ * one place a zone is a **tab strip**, where the count decides whether the
+ * strip exists at all (feature 091, P4d).
+ *
+ * **A separate subpath from `./contributions`, and the split is deliberate.**
+ * `./contributions` is the contributor's side and is data-only — a module's
+ * `src/admin/index.ts` imports it — while this subpath renders React. One
+ * subpath would let a declaration file import a component, which R2 of
+ * `admin-contribution.md` exists to prevent.
+ *
+ * The barrel is **explicit and holds no `export *`**, per
+ * `admin-kit-surface.md` R2.
+ */
+export { AdminZone } from './AdminZone.js';
+export { RouteTabsZone } from './RouteTabsZone.js';
+export { AdminContributionsProvider, AdminContributionsUnavailableError, useAdminContributions, } from './AdminContributionsProvider.js';
+export { matchesZoneProps, selectZoneContributions, useAdminZone } from './use-admin-zone.js';
+export { ZoneErrorBoundary } from './ZoneErrorBoundary.js';
+//# sourceMappingURL=index.js.map

package/dist/zones/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/zones/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EACL,0BAA0B,EAC1B,kCAAkC,EAClC,qBAAqB,GACtB,MAAM,iCAAiC,CAAC;AAMzC,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC9F,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/zones/use-admin-zone.d.ts

@@ -0,0 +1,32 @@
+import type { AdminZoneName, AdminZoneProps } from '@endora-commerce/contracts';
+import { type GatedSurface } from '../lib/surface-visibility.js';
+import { type OwnedZoneContribution } from './AdminContributionsProvider.js';
+/**
+ * Whether every key of `match` agrees with the mount's props.
+ *
+ * A contribution with no `match` matches every mount. A key the props do not
+ * carry never agrees — the fail-closed direction: a `match` naming a prop that
+ * does not exist hides the contribution, where the other answer would widen it
+ * silently.
+ *
+ * Comparison is by string value, so a non-string prop (`languageCodes`, an
+ * array) is not matchable and a `match` naming it hides the contribution. That
+ * is deliberate rather than a limit worked around: `match` is declarative data
+ * a check has to be able to read, and a structural comparison is not.
+ *
+ * Exported so a test can drive the predicate directly — the classification is
+ * what `match` is, and a test that reached it only through a rendered React
+ * tree would be asserting the renderer instead.
+ */
+export declare function matchesZoneProps(match: Readonly<Record<string, string | readonly string[]>> | undefined, props: Readonly<Record<string, unknown>>): boolean;
+/** The four steps, as a pure function of the registry, the props and the predicate. */
+export declare function selectZoneContributions(contributions: readonly OwnedZoneContribution[], zone: string, props: Readonly<Record<string, unknown>>, isVisible: (surface: GatedSurface) => boolean): readonly OwnedZoneContribution[];
+/**
+ * The contributions to render at this mount of `zone`, in order.
+ *
+ * The zone name is a **string literal** at every call site (Z7): the two-way
+ * refusal in `check:admin-zones` compares rendered names to declared ones, and
+ * a name it cannot read is a zone it would report as rendered by nobody.
+ */
+export declare function useAdminZone<Z extends AdminZoneName>(zone: Z, props: AdminZoneProps<Z>): readonly OwnedZoneContribution[];
+//# sourceMappingURL=use-admin-zone.d.ts.map

package/dist/zones/use-admin-zone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-admin-zone.d.ts","sourceRoot":"","sources":["../../src/zones/use-admin-zone.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEhF,OAAO,EAAwB,KAAK,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACvF,OAAO,EAAyB,KAAK,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAEpG;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC,CAAC,GAAG,SAAS,EACvE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,OAAO,CAYT;AAED,uFAAuF;AACvF,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,SAAS,qBAAqB,EAAE,EAC/C,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,SAAS,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,GAC5C,SAAS,qBAAqB,EAAE,CAkBlC;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,aAAa,EAClD,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GACvB,SAAS,qBAAqB,EAAE,CAalC"}

package/dist/zones/use-admin-zone.js

@@ -0,0 +1,96 @@
+/**
+ * The zone primitive — the visible, matched, ordered contributions for one
+ * place (feature 091, P4a; Z4/Z5, §4).
+ *
+ * ## Where the presence filter goes, and why it is here
+ *
+ * **The registry does not filter. This does, at enumeration.** That is
+ * D-67/D-68's boot-hook rule pointed at the frontend and the rule
+ * `admin/src/lib/module-registry/index.ts` already states for routes and nav:
+ * an operator's activation flip must take effect without a rebuild, so the
+ * registry answers *"what could be here"* and the enumeration answers *"what is
+ * here for this operator right now"*.
+ *
+ * ## The order the four steps run in is the design
+ *
+ *   1. the contributions whose `zone` is this one;
+ *   2. minus those whose `match` disagrees with the mount's props;
+ *   3. minus those `isSurfaceVisible({ module, requiredPermission })` rejects —
+ *      the one predicate (FR-012), now with a fourth caller and still no second
+ *      copy;
+ *   4. sorted by `weight`, then module id.
+ *
+ * Steps 2 and 3 are decided **before** `React.lazy` is touched, which is FR-013
+ * and not tidiness: a contributor that narrowed itself by returning `null`
+ * would have its chunk fetched and evaluated on every screen the zone is
+ * mounted on, and FR-013 says a module's admin page code must not be downloaded
+ * by a browser that cannot reach it.
+ *
+ * `module` is the registry entry's key and never a declared field (D-142), so a
+ * module cannot contribute under another module's presence.
+ */
+import { useMemo } from 'react';
+import { useSurfaceVisibility } from '../lib/surface-visibility.js';
+import { useAdminContributions } from './AdminContributionsProvider.js';
+/**
+ * Whether every key of `match` agrees with the mount's props.
+ *
+ * A contribution with no `match` matches every mount. A key the props do not
+ * carry never agrees — the fail-closed direction: a `match` naming a prop that
+ * does not exist hides the contribution, where the other answer would widen it
+ * silently.
+ *
+ * Comparison is by string value, so a non-string prop (`languageCodes`, an
+ * array) is not matchable and a `match` naming it hides the contribution. That
+ * is deliberate rather than a limit worked around: `match` is declarative data
+ * a check has to be able to read, and a structural comparison is not.
+ *
+ * Exported so a test can drive the predicate directly — the classification is
+ * what `match` is, and a test that reached it only through a rendered React
+ * tree would be asserting the renderer instead.
+ */
+export function matchesZoneProps(match, props) {
+    if (match === undefined)
+        return true;
+    for (const [key, wanted] of Object.entries(match)) {
+        const value = props[key];
+        if (typeof value !== 'string')
+            return false;
+        if (typeof wanted === 'string') {
+            if (wanted !== value)
+                return false;
+            continue;
+        }
+        if (!wanted.includes(value))
+            return false;
+    }
+    return true;
+}
+/** The four steps, as a pure function of the registry, the props and the predicate. */
+export function selectZoneContributions(contributions, zone, props, isVisible) {
+    return contributions
+        .filter((contribution) => contribution.zone === zone)
+        .filter((contribution) => matchesZoneProps(contribution.match, props))
+        .filter((contribution) => isVisible({
+        module: contribution.module,
+        // `exactOptionalPropertyTypes` is on: an absent requirement is an
+        // absent property, not an explicit `undefined`.
+        ...(contribution.requiredPermission === undefined
+            ? {}
+            : { requiredPermission: contribution.requiredPermission }),
+    }))
+        .sort((left, right) => left.weight - right.weight || left.module.localeCompare(right.module));
+}
+/**
+ * The contributions to render at this mount of `zone`, in order.
+ *
+ * The zone name is a **string literal** at every call site (Z7): the two-way
+ * refusal in `check:admin-zones` compares rendered names to declared ones, and
+ * a name it cannot read is a zone it would report as rendered by nobody.
+ */
+export function useAdminZone(zone, props) {
+    const contributions = useAdminContributions();
+    const isVisible = useSurfaceVisibility();
+    return useMemo(() => selectZoneContributions(contributions, zone, props, isVisible), [contributions, zone, props, isVisible]);
+}
+//# sourceMappingURL=use-admin-zone.js.map

package/dist/zones/use-admin-zone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-admin-zone.js","sourceRoot":"","sources":["../../src/zones/use-admin-zone.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAGhC,OAAO,EAAE,oBAAoB,EAAqB,MAAM,8BAA8B,CAAC;AACvF,OAAO,EAAE,qBAAqB,EAA8B,MAAM,iCAAiC,CAAC;AAEpG;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAAuE,EACvE,KAAwC;IAExC,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACrC,KAAK,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAClD,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;QACzB,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,OAAO,KAAK,CAAC;QAC5C,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC/B,IAAI,MAAM,KAAK,KAAK;gBAAE,OAAO,KAAK,CAAC;YACnC,SAAS;QACX,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;IAC5C,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,uFAAuF;AACvF,MAAM,UAAU,uBAAuB,CACrC,aAA+C,EAC/C,IAAY,EACZ,KAAwC,EACxC,SAA6C;IAE7C,OAAO,aAAa;SACjB,MAAM,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,KAAK,IAAI,CAAC;SACpD,MAAM,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,gBAAgB,CAAC,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;SACrE,MAAM,CAAC,CAAC,YAAY,EAAE,EAAE,CACvB,SAAS,CAAC;QACR,MAAM,EAAE,YAAY,CAAC,MAAM;QAC3B,kEAAkE;QAClE,gDAAgD;QAChD,GAAG,CAAC,YAAY,CAAC,kBAAkB,KAAK,SAAS;YAC/C,CAAC,CAAC,EAAE;YACJ,CAAC,CAAC,EAAE,kBAAkB,EAAE,YAAY,CAAC,kBAAkB,EAAE,CAAC;KAC7D,CAAC,CACH;SACA,IAAI,CACH,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CACd,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,CACxE,CAAC;AACN,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAC1B,IAAO,EACP,KAAwB;IAExB,MAAM,aAAa,GAAG,qBAAqB,EAAE,CAAC;IAC9C,MAAM,SAAS,GAAG,oBAAoB,EAAE,CAAC;IACzC,OAAO,OAAO,CACZ,GAAG,EAAE,CACH,uBAAuB,CACrB,aAAa,EACb,IAAI,EACJ,KAAqD,EACrD,SAAS,CACV,EACH,CAAC,aAAa,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,CACxC,CAAC;AACJ,CAAC"}