@wildo-ai/saas-frontend-lib 1.0.1 → 1.1.1

package/dist/esm/core/resources/in-place/InPlaceOperationContext.d.ts

@@ -0,0 +1,109 @@
+import React from 'react';
+import type { FrontendResourceConfiguration_Operation, FrontendResourceOperationContext } from '../../../core/resources/resources.frontend.schemas';
+/**
+ * Where an ELEMENT-LEVEL operation is hosted — the mechanism behind
+ * `ResourceOperationActionPresentation.INLINE` and `NavigationTransition.INPLACE`.
+ *
+ * ## Why this is NOT part of navigation
+ *
+ * `NavigationTransition.INPLACE` has existed since the navigation model was written and has never
+ * done what its own docstring promises ("operates at the element level, not the zone level",
+ * "surrounding items remain visible", "the zone stack is unchanged"). What it actually did was
+ * resolve to the source zone and emit `NAVIGATION_REPLACE` — swapping the whole zone, which is
+ * precisely REPLACE. The preset inline-edit kit has shipped it for CREATE/UPDATE the whole time.
+ *
+ * The reason it stayed hollow is visible in that list of promises: element-level hosting uses NONE
+ * of what the navigation layer provides. No zone, no stack entry, no transition verb, no appearance,
+ * no lifecycle modifier. Routing it through a resolver whose entire vocabulary it declines left the
+ * controller holding a verb it had nothing to do with, so it fell through to the nearest thing that
+ * did something — and that fall-through IS the defect. Building the element-level host inside
+ * navigation would have re-created it one layer down.
+ *
+ * So the host lives where the elements are: a COLLECTION provides it, and BOTH tiers that can select
+ * it ask for it here — the per-operation `ResourceOperationActionPresentation.INLINE`, and the
+ * class-level `NavigationTransition.INPLACE` that an app authors in a zone's `transitions`, its
+ * `appLevel.transitions`, or a relationship's `display.inParentNavigation`. Two tiers, one host, so
+ * there is nothing for them to drift apart about.
+ *
+ * The controller reaches it through REACT CONTEXT rather than an event, and that is load-bearing
+ * rather than incidental: the NEAREST provider wins automatically, so a nested child list transforms
+ * its own row and not the parent list's row of the same resource type. An event would have to carry
+ * enough identity to disambiguate two mounted collections, and would still be guessing.
+ *
+ * ## The degrade, and why it is not optional
+ *
+ * An in-place host only exists inside a collection. The same action can also be rendered on a detail
+ * page, in a danger zone, or in a picker, where there is no row to transform. `isAvailable` reports
+ * that honestly so the caller can fall back to an overlay, instead of an action that silently does
+ * nothing in half the places it renders.
+ */
+/**
+ * What an element-level host is hosting.
+ *
+ * Two shapes, because a CREATE has no element to transform. Modelling it as an `elementId` of `''`
+ * or `'new'` would make every consumer's `isElementActive` check accidentally true for a row whose
+ * id failed to resolve — the two cases must not be able to collide, so they are separate members.
+ */
+export declare enum InPlaceOperationTargetKind {
+    /** An EXISTING element transforms into the operation's form. */
+    ELEMENT = "element",
+    /** A NEW element materialises in the collection to collect the operation's input. */
+    CREATE = "create"
+}
+interface InPlaceOperationTargetBase {
+    /** The operation being hosted, resolved to its exact variant. */
+    operation: FrontendResourceConfiguration_Operation;
+    /** The context the host renders the operation with — identical to what any other host receives. */
+    resourceContext: FrontendResourceOperationContext;
+}
+export type InPlaceOperationTarget = (InPlaceOperationTargetBase & {
+    kind: InPlaceOperationTargetKind.ELEMENT;
+    /** The row being transformed, by its addressable object id. */
+    elementId: string;
+}) | (InPlaceOperationTargetBase & {
+    kind: InPlaceOperationTargetKind.CREATE;
+});
+export interface InPlaceOperationController {
+    /**
+     * Is an element-level host mounted above this point in the tree?
+     *
+     * `false` outside a collection. A caller MUST branch on it rather than calling `open()` and hoping
+     * — see the degrade rationale above.
+     */
+    isAvailable: boolean;
+    /** What is currently hosted, or `null`. At most one per collection. */
+    target: InPlaceOperationTarget | null;
+    open: (target: InPlaceOperationTarget) => void;
+    close: () => void;
+    /** Is THIS element the one currently transformed? The predicate a row renderer asks. */
+    isElementActive: (elementId: string) => boolean;
+    /**
+     * Is a NEW element being collected? The predicate a collection asks before rendering the extra
+     * leading element that has no row of its own.
+     */
+    isCreateActive: boolean;
+}
+export interface InPlaceOperationProviderProps {
+    /**
+     * The resource whose elements this host owns.
+     *
+     * Nested collections mean nested providers, and the inner one shadows the outer for its own
+     * subtree. Carrying the resource type makes a mismatched request refusable rather than silently
+     * transforming a row of the wrong list — an inner provider that accepted anything would turn a
+     * child-list action into a parent-row transformation.
+     */
+    resourceType: string;
+    children: React.ReactNode;
+}
+export declare function InPlaceOperationProvider({ resourceType, children, }: InPlaceOperationProviderProps): React.JSX.Element;
+/**
+ * Read the element-level host.
+ *
+ * Never throws when absent — it returns an UNAVAILABLE controller instead, because "there is no
+ * collection here" is an ordinary, expected situation for an action bar (a detail page, a danger
+ * zone, a picker) and not a misconfiguration. A throwing hook would force every action surface to
+ * know whether it happens to be inside a list.
+ */
+export declare function useInPlaceOperation(): InPlaceOperationController;
+export {};
+//# sourceMappingURL=InPlaceOperationContext.d.ts.map

package/dist/esm/core/resources/in-place/InPlaceOperationContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InPlaceOperationContext.d.ts","sourceRoot":"","sources":["../../../../../../src/core/resources/in-place/InPlaceOperationContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoE,MAAM,OAAO,CAAC;AAEzF,OAAO,KAAK,EAAE,uCAAuC,EAAE,gCAAgC,EAAE,MAAM,+DAA+D,CAAC;AAE/J;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;;;;;;GAMG;AACH,oBAAY,0BAA0B;IACpC,gEAAgE;IAChE,OAAO,YAAY;IACnB,qFAAqF;IACrF,MAAM,WAAW;CAClB;AAED,UAAU,0BAA0B;IAClC,iEAAiE;IACjE,SAAS,EAAE,uCAAuC,CAAC;IACnD,mGAAmG;IACnG,eAAe,EAAE,gCAAgC,CAAC;CACnD;AAED,MAAM,MAAM,sBAAsB,GAC9B,CAAC,0BAA0B,GAAG;IAC5B,IAAI,EAAE,0BAA0B,CAAC,OAAO,CAAC;IACzC,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC,GACF,CAAC,0BAA0B,GAAG;IAC5B,IAAI,EAAE,0BAA0B,CAAC,MAAM,CAAC;CACzC,CAAC,CAAC;AAEP,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB,uEAAuE;IACvE,MAAM,EAAE,sBAAsB,GAAG,IAAI,CAAC;IACtC,IAAI,EAAE,CAAC,MAAM,EAAE,sBAAsB,KAAK,IAAI,CAAC;IAC/C,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,wFAAwF;IACxF,eAAe,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;IAChD;;;OAGG;IACH,cAAc,EAAE,OAAO,CAAC;CACzB;AAaD,MAAM,WAAW,6BAA6B;IAC5C;;;;;;;OAOG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED,wBAAgB,wBAAwB,CAAC,EACvC,YAAY,EACZ,QAAQ,GACT,EAAE,6BAA6B,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAoCnD;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,IAAI,0BAA0B,CAEhE"}

package/dist/esm/core/resources/in-place/InPlaceOperationContext.js

@@ -0,0 +1,103 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useMemo, useState } from 'react';
+/**
+ * Where an ELEMENT-LEVEL operation is hosted — the mechanism behind
+ * `ResourceOperationActionPresentation.INLINE` and `NavigationTransition.INPLACE`.
+ *
+ * ## Why this is NOT part of navigation
+ *
+ * `NavigationTransition.INPLACE` has existed since the navigation model was written and has never
+ * done what its own docstring promises ("operates at the element level, not the zone level",
+ * "surrounding items remain visible", "the zone stack is unchanged"). What it actually did was
+ * resolve to the source zone and emit `NAVIGATION_REPLACE` — swapping the whole zone, which is
+ * precisely REPLACE. The preset inline-edit kit has shipped it for CREATE/UPDATE the whole time.
+ *
+ * The reason it stayed hollow is visible in that list of promises: element-level hosting uses NONE
+ * of what the navigation layer provides. No zone, no stack entry, no transition verb, no appearance,
+ * no lifecycle modifier. Routing it through a resolver whose entire vocabulary it declines left the
+ * controller holding a verb it had nothing to do with, so it fell through to the nearest thing that
+ * did something — and that fall-through IS the defect. Building the element-level host inside
+ * navigation would have re-created it one layer down.
+ *
+ * So the host lives where the elements are: a COLLECTION provides it, and BOTH tiers that can select
+ * it ask for it here — the per-operation `ResourceOperationActionPresentation.INLINE`, and the
+ * class-level `NavigationTransition.INPLACE` that an app authors in a zone's `transitions`, its
+ * `appLevel.transitions`, or a relationship's `display.inParentNavigation`. Two tiers, one host, so
+ * there is nothing for them to drift apart about.
+ *
+ * The controller reaches it through REACT CONTEXT rather than an event, and that is load-bearing
+ * rather than incidental: the NEAREST provider wins automatically, so a nested child list transforms
+ * its own row and not the parent list's row of the same resource type. An event would have to carry
+ * enough identity to disambiguate two mounted collections, and would still be guessing.
+ *
+ * ## The degrade, and why it is not optional
+ *
+ * An in-place host only exists inside a collection. The same action can also be rendered on a detail
+ * page, in a danger zone, or in a picker, where there is no row to transform. `isAvailable` reports
+ * that honestly so the caller can fall back to an overlay, instead of an action that silently does
+ * nothing in half the places it renders.
+ */
+/**
+ * What an element-level host is hosting.
+ *
+ * Two shapes, because a CREATE has no element to transform. Modelling it as an `elementId` of `''`
+ * or `'new'` would make every consumer's `isElementActive` check accidentally true for a row whose
+ * id failed to resolve — the two cases must not be able to collide, so they are separate members.
+ */
+export var InPlaceOperationTargetKind;
+(function (InPlaceOperationTargetKind) {
+    /** An EXISTING element transforms into the operation's form. */
+    InPlaceOperationTargetKind["ELEMENT"] = "element";
+    /** A NEW element materialises in the collection to collect the operation's input. */
+    InPlaceOperationTargetKind["CREATE"] = "create";
+})(InPlaceOperationTargetKind || (InPlaceOperationTargetKind = {}));
+const UNAVAILABLE_CONTROLLER = {
+    isAvailable: false,
+    target: null,
+    open: () => undefined,
+    close: () => undefined,
+    isElementActive: () => false,
+    isCreateActive: false,
+};
+const InPlaceOperationContext = createContext(UNAVAILABLE_CONTROLLER);
+export function InPlaceOperationProvider({ resourceType, children, }) {
+    const [target, setTarget] = useState(null);
+    const open = useCallback((next) => {
+        if (next.resourceContext.resourceType !== resourceType) {
+            // A request for another resource's element. Refused rather than rendered: the caller's degrade
+            // path (an overlay) is the correct outcome, and transforming an unrelated row would be worse
+            // than doing nothing.
+            return;
+        }
+        setTarget(next);
+    }, [resourceType]);
+    const close = useCallback(() => setTarget(null), []);
+    const isElementActive = useCallback((elementId) => {
+        // An empty id can never match. A row whose object id failed to resolve would otherwise match the
+        // same empty string a second unresolved row produces, transforming an arbitrary one of them.
+        if (!elementId)
+            return false;
+        return target?.kind === InPlaceOperationTargetKind.ELEMENT && target.elementId === elementId;
+    }, [target]);
+    const controller = useMemo(() => ({
+        isAvailable: true,
+        target,
+        open,
+        close,
+        isElementActive,
+        isCreateActive: target?.kind === InPlaceOperationTargetKind.CREATE,
+    }), [target, open, close, isElementActive]);
+    return (_jsx(InPlaceOperationContext.Provider, { value: controller, children: children }));
+}
+/**
+ * Read the element-level host.
+ *
+ * Never throws when absent — it returns an UNAVAILABLE controller instead, because "there is no
+ * collection here" is an ordinary, expected situation for an action bar (a detail page, a danger
+ * zone, a picker) and not a misconfiguration. A throwing hook would force every action surface to
+ * know whether it happens to be inside a list.
+ */
+export function useInPlaceOperation() {
+    return useContext(InPlaceOperationContext);
+}
+//# sourceMappingURL=InPlaceOperationContext.js.map

package/dist/esm/core/resources/in-place/InPlaceOperationContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InPlaceOperationContext.js","sourceRoot":"","sources":["../../../../../../src/core/resources/in-place/InPlaceOperationContext.tsx"],"names":[],"mappings":";AAAA,OAAc,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAIzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;;;;;;GAMG;AACH,MAAM,CAAN,IAAY,0BAKX;AALD,WAAY,0BAA0B;IACpC,gEAAgE;IAChE,iDAAmB,CAAA;IACnB,qFAAqF;IACrF,+CAAiB,CAAA;AACnB,CAAC,EALW,0BAA0B,KAA1B,0BAA0B,QAKrC;AAwCD,MAAM,sBAAsB,GAA+B;IACzD,WAAW,EAAE,KAAK;IAClB,MAAM,EAAE,IAAI;IACZ,IAAI,EAAE,GAAG,EAAE,CAAC,SAAS;IACrB,KAAK,EAAE,GAAG,EAAE,CAAC,SAAS;IACtB,eAAe,EAAE,GAAG,EAAE,CAAC,KAAK;IAC5B,cAAc,EAAE,KAAK;CACtB,CAAC;AAEF,MAAM,uBAAuB,GAAG,aAAa,CAA6B,sBAAsB,CAAC,CAAC;AAelG,MAAM,UAAU,wBAAwB,CAAC,EACvC,YAAY,EACZ,QAAQ,GACsB;IAC9B,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,QAAQ,CAAgC,IAAI,CAAC,CAAC;IAE1E,MAAM,IAAI,GAAG,WAAW,CAAC,CAAC,IAA4B,EAAE,EAAE;QACxD,IAAI,IAAI,CAAC,eAAe,CAAC,YAAY,KAAK,YAAY,EAAE,CAAC;YACvD,+FAA+F;YAC/F,6FAA6F;YAC7F,sBAAsB;YACtB,OAAO;QACT,CAAC;QACD,SAAS,CAAC,IAAI,CAAC,CAAC;IAClB,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC;IAEnB,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;IAErD,MAAM,eAAe,GAAG,WAAW,CAAC,CAAC,SAAiB,EAAE,EAAE;QACxD,iGAAiG;QACjG,6FAA6F;QAC7F,IAAI,CAAC,SAAS;YAAE,OAAO,KAAK,CAAC;QAC7B,OAAO,MAAM,EAAE,IAAI,KAAK,0BAA0B,CAAC,OAAO,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS,CAAC;IAC/F,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;IAEb,MAAM,UAAU,GAAG,OAAO,CAA6B,GAAG,EAAE,CAAC,CAAC;QAC5D,WAAW,EAAE,IAAI;QACjB,MAAM;QACN,IAAI;QACJ,KAAK;QACL,eAAe;QACf,cAAc,EAAE,MAAM,EAAE,IAAI,KAAK,0BAA0B,CAAC,MAAM;KACnE,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC;IAE5C,OAAO,CACL,KAAC,uBAAuB,CAAC,QAAQ,IAAC,KAAK,EAAE,UAAU,YAChD,QAAQ,GACwB,CACpC,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB;IACjC,OAAO,UAAU,CAAC,uBAAuB,CAAC,CAAC;AAC7C,CAAC","sourcesContent":["import React, { createContext, useCallback, useContext, useMemo, useState } from 'react';\n\nimport type { FrontendResourceConfiguration_Operation, FrontendResourceOperationContext } from '~wildo-frontend-lib/core/resources/resources.frontend.schemas';\n\n/**\n * Where an ELEMENT-LEVEL operation is hosted — the mechanism behind\n * `ResourceOperationActionPresentation.INLINE` and `NavigationTransition.INPLACE`.\n *\n * ## Why this is NOT part of navigation\n *\n * `NavigationTransition.INPLACE` has existed since the navigation model was written and has never\n * done what its own docstring promises (\"operates at the element level, not the zone level\",\n * \"surrounding items remain visible\", \"the zone stack is unchanged\"). What it actually did was\n * resolve to the source zone and emit `NAVIGATION_REPLACE` — swapping the whole zone, which is\n * precisely REPLACE. The preset inline-edit kit has shipped it for CREATE/UPDATE the whole time.\n *\n * The reason it stayed hollow is visible in that list of promises: element-level hosting uses NONE\n * of what the navigation layer provides. No zone, no stack entry, no transition verb, no appearance,\n * no lifecycle modifier. Routing it through a resolver whose entire vocabulary it declines left the\n * controller holding a verb it had nothing to do with, so it fell through to the nearest thing that\n * did something — and that fall-through IS the defect. Building the element-level host inside\n * navigation would have re-created it one layer down.\n *\n * So the host lives where the elements are: a COLLECTION provides it, and BOTH tiers that can select\n * it ask for it here — the per-operation `ResourceOperationActionPresentation.INLINE`, and the\n * class-level `NavigationTransition.INPLACE` that an app authors in a zone's `transitions`, its\n * `appLevel.transitions`, or a relationship's `display.inParentNavigation`. Two tiers, one host, so\n * there is nothing for them to drift apart about.\n *\n * The controller reaches it through REACT CONTEXT rather than an event, and that is load-bearing\n * rather than incidental: the NEAREST provider wins automatically, so a nested child list transforms\n * its own row and not the parent list's row of the same resource type. An event would have to carry\n * enough identity to disambiguate two mounted collections, and would still be guessing.\n *\n * ## The degrade, and why it is not optional\n *\n * An in-place host only exists inside a collection. The same action can also be rendered on a detail\n * page, in a danger zone, or in a picker, where there is no row to transform. `isAvailable` reports\n * that honestly so the caller can fall back to an overlay, instead of an action that silently does\n * nothing in half the places it renders.\n */\n/**\n * What an element-level host is hosting.\n *\n * Two shapes, because a CREATE has no element to transform. Modelling it as an `elementId` of `''`\n * or `'new'` would make every consumer's `isElementActive` check accidentally true for a row whose\n * id failed to resolve — the two cases must not be able to collide, so they are separate members.\n */\nexport enum InPlaceOperationTargetKind {\n  /** An EXISTING element transforms into the operation's form. */\n  ELEMENT = 'element',\n  /** A NEW element materialises in the collection to collect the operation's input. */\n  CREATE = 'create',\n}\n\ninterface InPlaceOperationTargetBase {\n  /** The operation being hosted, resolved to its exact variant. */\n  operation: FrontendResourceConfiguration_Operation;\n  /** The context the host renders the operation with — identical to what any other host receives. */\n  resourceContext: FrontendResourceOperationContext;\n}\n\nexport type InPlaceOperationTarget =\n  | (InPlaceOperationTargetBase & {\n      kind: InPlaceOperationTargetKind.ELEMENT;\n      /** The row being transformed, by its addressable object id. */\n      elementId: string;\n    })\n  | (InPlaceOperationTargetBase & {\n      kind: InPlaceOperationTargetKind.CREATE;\n    });\n\nexport interface InPlaceOperationController {\n  /**\n   * Is an element-level host mounted above this point in the tree?\n   *\n   * `false` outside a collection. A caller MUST branch on it rather than calling `open()` and hoping\n   * — see the degrade rationale above.\n   */\n  isAvailable: boolean;\n  /** What is currently hosted, or `null`. At most one per collection. */\n  target: InPlaceOperationTarget | null;\n  open: (target: InPlaceOperationTarget) => void;\n  close: () => void;\n  /** Is THIS element the one currently transformed? The predicate a row renderer asks. */\n  isElementActive: (elementId: string) => boolean;\n  /**\n   * Is a NEW element being collected? The predicate a collection asks before rendering the extra\n   * leading element that has no row of its own.\n   */\n  isCreateActive: boolean;\n}\n\nconst UNAVAILABLE_CONTROLLER: InPlaceOperationController = {\n  isAvailable: false,\n  target: null,\n  open: () => undefined,\n  close: () => undefined,\n  isElementActive: () => false,\n  isCreateActive: false,\n};\n\nconst InPlaceOperationContext = createContext<InPlaceOperationController>(UNAVAILABLE_CONTROLLER);\n\nexport interface InPlaceOperationProviderProps {\n  /**\n   * The resource whose elements this host owns.\n   *\n   * Nested collections mean nested providers, and the inner one shadows the outer for its own\n   * subtree. Carrying the resource type makes a mismatched request refusable rather than silently\n   * transforming a row of the wrong list — an inner provider that accepted anything would turn a\n   * child-list action into a parent-row transformation.\n   */\n  resourceType: string;\n  children: React.ReactNode;\n}\n\nexport function InPlaceOperationProvider({\n  resourceType,\n  children,\n}: InPlaceOperationProviderProps): React.JSX.Element {\n  const [target, setTarget] = useState<InPlaceOperationTarget | null>(null);\n\n  const open = useCallback((next: InPlaceOperationTarget) => {\n    if (next.resourceContext.resourceType !== resourceType) {\n      // A request for another resource's element. Refused rather than rendered: the caller's degrade\n      // path (an overlay) is the correct outcome, and transforming an unrelated row would be worse\n      // than doing nothing.\n      return;\n    }\n    setTarget(next);\n  }, [resourceType]);\n\n  const close = useCallback(() => setTarget(null), []);\n\n  const isElementActive = useCallback((elementId: string) => {\n    // An empty id can never match. A row whose object id failed to resolve would otherwise match the\n    // same empty string a second unresolved row produces, transforming an arbitrary one of them.\n    if (!elementId) return false;\n    return target?.kind === InPlaceOperationTargetKind.ELEMENT && target.elementId === elementId;\n  }, [target]);\n\n  const controller = useMemo<InPlaceOperationController>(() => ({\n    isAvailable: true,\n    target,\n    open,\n    close,\n    isElementActive,\n    isCreateActive: target?.kind === InPlaceOperationTargetKind.CREATE,\n  }), [target, open, close, isElementActive]);\n\n  return (\n    <InPlaceOperationContext.Provider value={controller}>\n      {children}\n    </InPlaceOperationContext.Provider>\n  );\n}\n\n/**\n * Read the element-level host.\n *\n * Never throws when absent — it returns an UNAVAILABLE controller instead, because \"there is no\n * collection here\" is an ordinary, expected situation for an action bar (a detail page, a danger\n * zone, a picker) and not a misconfiguration. A throwing hook would force every action surface to\n * know whether it happens to be inside a list.\n */\nexport function useInPlaceOperation(): InPlaceOperationController {\n  return useContext(InPlaceOperationContext);\n}\n"]}

package/dist/esm/core/resources/operation-initiator-satisfaction.frontend.utils.d.ts

@@ -0,0 +1,7 @@
+import type { FrontendResourceConfiguration_Operation, FrontendResourceOperationContext } from './resources.frontend.schemas';
+export declare function operationInitiatorParametersSatisfied(params: {
+    operation: FrontendResourceConfiguration_Operation;
+    contextResourceIdentifiers: FrontendResourceOperationContext['contextResourceIdentifiers'];
+    contextualParameters: Record<string, string | number>;
+}): boolean;
+//# sourceMappingURL=operation-initiator-satisfaction.frontend.utils.d.ts.map

package/dist/esm/core/resources/operation-initiator-satisfaction.frontend.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation-initiator-satisfaction.frontend.utils.d.ts","sourceRoot":"","sources":["../../../../../src/core/resources/operation-initiator-satisfaction.frontend.utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uCAAuC,EAAE,gCAAgC,EAAE,MAAM,8BAA8B,CAAC;AAG9H,wBAAgB,qCAAqC,CAAC,MAAM,EAAE;IAC5D,SAAS,EAAE,uCAAuC,CAAC;IACnD,0BAA0B,EAAE,gCAAgC,CAAC,4BAA4B,CAAC,CAAC;IAC3F,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;CACvD,GAAG,OAAO,CAkCV"}

package/dist/esm/core/resources/operation-initiator-satisfaction.frontend.utils.js

@@ -0,0 +1,32 @@
+import { frontendResourceUtils } from './frontend-resource.utils.js';
+export function operationInitiatorParametersSatisfied(params) {
+    const initiatorInfos = params.operation.initiatorInfos ?? [];
+    if (initiatorInfos.length === 0) {
+        return true;
+    }
+    return initiatorInfos.some((initiatorInfo) => {
+        const parameters = initiatorInfo.parameters ?? [];
+        if (parameters.length === 0) {
+            return true;
+        }
+        return parameters.every((parameter) => {
+            const candidateKeys = [
+                parameter.fieldIdentifier,
+                parameter.relationshipField,
+                parameter.resourceType,
+            ].filter((key) => typeof key === 'string' && key.length > 0);
+            if (candidateKeys.length === 0) {
+                return false;
+            }
+            return candidateKeys.some((key) => {
+                const contextResourceId = frontendResourceUtils.getResourceId(params.contextResourceIdentifiers[key]);
+                if (contextResourceId.length > 0) {
+                    return true;
+                }
+                const contextualValue = params.contextualParameters[key];
+                return contextualValue !== undefined && String(contextualValue).length > 0;
+            });
+        });
+    });
+}
+//# sourceMappingURL=operation-initiator-satisfaction.frontend.utils.js.map

package/dist/esm/core/resources/operation-initiator-satisfaction.frontend.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation-initiator-satisfaction.frontend.utils.js","sourceRoot":"","sources":["../../../../../src/core/resources/operation-initiator-satisfaction.frontend.utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAElE,MAAM,UAAU,qCAAqC,CAAC,MAIrD;IACC,MAAM,cAAc,GAAG,MAAM,CAAC,SAAS,CAAC,cAAc,IAAI,EAAE,CAAC;IAC7D,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAChC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,cAAc,CAAC,IAAI,CAAC,CAAC,aAAa,EAAE,EAAE;QAC3C,MAAM,UAAU,GAAG,aAAa,CAAC,UAAU,IAAI,EAAE,CAAC;QAClD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,EAAE,EAAE;YACpC,MAAM,aAAa,GAAG;gBACpB,SAAS,CAAC,eAAe;gBACzB,SAAS,CAAC,iBAAiB;gBAC3B,SAAS,CAAC,YAAY;aACvB,CAAC,MAAM,CAAC,CAAC,GAAG,EAAiB,EAAE,CAAC,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YAE5E,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAC/B,OAAO,KAAK,CAAC;YACf,CAAC;YAED,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE;gBAChC,MAAM,iBAAiB,GAAG,qBAAqB,CAAC,aAAa,CAAC,MAAM,CAAC,0BAA0B,CAAC,GAAG,CAAC,CAAC,CAAC;gBACtG,IAAI,iBAAiB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACjC,OAAO,IAAI,CAAC;gBACd,CAAC;gBAED,MAAM,eAAe,GAAG,MAAM,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC;gBACzD,OAAO,eAAe,KAAK,SAAS,IAAI,MAAM,CAAC,eAAe,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;YAC7E,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { FrontendResourceConfiguration_Operation, FrontendResourceOperationContext } from './resources.frontend.schemas';\nimport { frontendResourceUtils } from './frontend-resource.utils';\n\nexport function operationInitiatorParametersSatisfied(params: {\n  operation: FrontendResourceConfiguration_Operation;\n  contextResourceIdentifiers: FrontendResourceOperationContext['contextResourceIdentifiers'];\n  contextualParameters: Record<string, string | number>;\n}): boolean {\n  const initiatorInfos = params.operation.initiatorInfos ?? [];\n  if (initiatorInfos.length === 0) {\n    return true;\n  }\n\n  return initiatorInfos.some((initiatorInfo) => {\n    const parameters = initiatorInfo.parameters ?? [];\n    if (parameters.length === 0) {\n      return true;\n    }\n\n    return parameters.every((parameter) => {\n      const candidateKeys = [\n        parameter.fieldIdentifier,\n        parameter.relationshipField,\n        parameter.resourceType,\n      ].filter((key): key is string => typeof key === 'string' && key.length > 0);\n\n      if (candidateKeys.length === 0) {\n        return false;\n      }\n\n      return candidateKeys.some((key) => {\n        const contextResourceId = frontendResourceUtils.getResourceId(params.contextResourceIdentifiers[key]);\n        if (contextResourceId.length > 0) {\n          return true;\n        }\n\n        const contextualValue = params.contextualParameters[key];\n        return contextualValue !== undefined && String(contextualValue).length > 0;\n      });\n    });\n  });\n}\n"]}

package/dist/esm/core/resources/operation-semantics.frontend.utils.d.ts

@@ -1,4 +1,5 @@
-import { CoreResourceOperation } from '@wildo-ai/saas-models';
+import { CoreResourceOperation, ResourceOperationFrontendSurface, NavigationTransition } from '@wildo-ai/saas-models';
+import { ResourceOperationActionPresentation, ResourceOperationActionScope } from '../../core/resources/resources.frontend.schemas';
 export interface ResourceOperationSemanticsLike {
     operationIdentifier: unknown;
     resourceOperationLike?: unknown;
@@ -7,8 +8,23 @@ export interface ResourceOperationSemanticsLike {
     isOperationDefault?: boolean;
     isBulkOperation?: boolean;
     variantKey?: unknown;
+    /**
+     * The subset of `ResourceOperationFrontendConfig` this module's decisions read.
+     *
+     * Deliberately a structural subset rather than the full config type: these helpers run against
+     * operation objects arriving through several projections (the frontend registry, a thinned
+     * navigation payload, a test fixture), and requiring the whole config would make them unusable on
+     * exactly the surfaces that need them most.
+     */
     operationFrontendConfig?: {
-        isAddressable?: boolean;
+        surface?: ResourceOperationFrontendSurface;
+        actionPresentation?: ResourceOperationActionPresentation;
+        actionScope?: ResourceOperationActionScope;
+        rowTargetRequestField?: string;
+    };
+    generatedOperation?: {
+        kind?: unknown;
+        fieldName?: unknown;
     };
 }
 export declare const BULK_OPERATION_SELECTION_IDS_CONTEXT_KEY = "bulkOperationSelectionIds";
@@ -23,16 +39,138 @@ export declare function isSingleResourceUpdateLikeOperation(operation: ResourceO
 export declare function shouldEmitResourceRefreshAfterDirectOperation(operation: ResourceOperationSemanticsLike): boolean;
 export declare function readBulkOperationSelectionIds(additionalContext?: Record<string, unknown>): string[] | undefined;
 export declare function readResourceOperationExecutedDiscriminator(additionalContext?: Record<string, unknown>): string | undefined;
+/**
+ * Build the wire selector a bulk operation uses to name the rows it targets.
+ *
+ * The field name comes from {@link BULK_OPERATION_SELECTOR_FIELD} — the ONE named source both halves
+ * of the contract read — because spelling it here is exactly how this broke. Every frontend bulk
+ * surface emitted `ids`, which is not in the bulk request DTO
+ * (`Resouces_BulkOperationBaseSchema.extend(...)`), so the strict Zod parse stripped it and then
+ * refused the request for the `_ids` it never received. It type-checked, it looked right, and the
+ * generic bulk lane had never once worked from the UI.
+ *
+ * Every frontend producer of a bulk payload goes through this function, so there is one spelling to
+ * get right rather than one per surface.
+ */
+export declare function buildBulkOperationSelectorPayload(ids: readonly string[]): Record<string, unknown>;
 export declare function mergeBulkSelectionIntoRequestData(params: {
     operation: ResourceOperationSemanticsLike;
     requestData?: Record<string, unknown>;
     additionalContext?: Record<string, unknown>;
 }): Record<string, unknown> | undefined;
 export declare function isSemanticCustomResourceOperation(operation: ResourceOperationSemanticsLike): boolean;
+export declare function isGeneratedFileRegenerateOperation(operation: ResourceOperationSemanticsLike): boolean;
+/**
+ * Is this the CSV/JSON export companion of a LIST/SEARCH operation?
+ *
+ * Identity comes from the generated-operation metadata, with the prefixed identifier as the fallback
+ * for any surface that receives a thinned operation object — the same two-source shape
+ * {@link isGeneratedFileRegenerateOperation} uses, and for the same reason: the frontend receives
+ * operations through several projections and not all of them carry `generatedOperation`.
+ */
+export declare function isGeneratedCollectionExportOperation(operation: ResourceOperationSemanticsLike): boolean;
 export declare const NON_ITEM_RESOURCE_OPERATIONS: Set<CoreResourceOperation>;
+/**
+ * Effective core semantics that are pure aggregate / collection READS — a data
+ * provider the surface calls programmatically, never a per-item user action,
+ * even when worn by a CUSTOM operation. A `get_state` op declaring
+ * `resourceOperationLike: COUNT` (no `requestDto`) is the canonical example: it
+ * fetches aggregate state for a panel to render, so as an action-bar button it is
+ * a dead control that fetches and shows nothing.
+ *
+ * `READ` and `CREATE` are deliberately EXCLUDED: custom READ-like ops
+ * (`open_portal`, `usage_stats`) and CREATE-like ops (a "clone" / "duplicate")
+ * ARE real user actions and must keep their button.
+ */
+export declare const NON_ITEM_CUSTOM_CORE_SEMANTICS: Set<CoreResourceOperation>;
 export declare const NAVIGABLE_RESOURCE_OPERATIONS: Set<CoreResourceOperation>;
 export declare function shouldTreatAsNonItemResourceOperation(operation: ResourceOperationSemanticsLike): boolean;
-export declare function shouldNavigateResourceOperation(operation: ResourceOperationSemanticsLike): boolean;
+/**
+ * The largest request-body field count the framework will present in an OVERLAY rather than a page.
+ *
+ * Six is a judgement, not a measurement, and it is written down here — in ONE place, named — so it
+ * can be argued with instead of rediscovered. It is the point at which the industry guidance stops
+ * saying "keep the user in context" and starts saying "give the task the room a page has": Carbon
+ * routes complex data entry to a full page, Filament's `->form()` modal is described for collecting
+ * *extra information*, not for authoring a record.
+ *
+ * An author who disagrees for a specific operation does not tune this number — they declare
+ * `actionPresentation` and the derivation is not consulted at all. That is the escape hatch, and it
+ * is why a single global constant is honest here.
+ */
+export declare const ACTION_MODAL_FIELD_CEILING = 6;
+/**
+ * Does this operation declare a request body with NO fields — an explicit `z.object({})`?
+ *
+ * Such a zero-input operation has no form to collect, so it executes rather than opening one.
+ * Mirrors the backend's `hasMeaningfulExplicitRequestDto` (inverted).
+ */
+export declare function hasEmptyResourceOperationRequestBody(requestDto: unknown): boolean;
+/**
+ * HOW does this action collect its input?
+ *
+ * The single answer for every action surface. An explicitly authored
+ * {@link ResourceOperationActionPresentation} is returned untouched — the author has answered the
+ * question and the framework does not second-guess them. Everything below is the DERIVATION for the
+ * (overwhelmingly common) case where nothing was authored.
+ *
+ * The derivation is ordered by how strong the evidence is, not by convenience:
+ *
+ * 1. **`ADDRESSABLE` ⇒ PAGE.** Declaring an operation deep-linkable IS declaring it a destination.
+ *    Nothing derived may take that away.
+ * 2. **A literal core CREATE / READ / UPDATE ⇒ PAGE.** These are the framework's own page surfaces
+ *    and every app's navigation config is written against them; deriving an overlay here would
+ *    silently restyle every existing application.
+ * 3. **Already-established in-place shapes ⇒ DIRECT.** A row-targeted action (its target rides the
+ *    body), a zero-input collection action, and a generated-file regenerate all executed on click
+ *    before this axis existed. They are stated here so the axis DESCRIBES the framework's behaviour
+ *    rather than sitting beside it — an axis that cannot express what the framework already does is
+ *    a second mechanism, not a vocabulary.
+ * 4. **No caller input ⇒ DIRECT.** No `requestDto` at all, or an explicit `z.object({})`.
+ * 5. **Input that fits an overlay ⇒ MODAL.** The new behaviour, and the reason the axis exists.
+ * 6. **Everything else ⇒ PAGE.** Files, nested writes, large field sets — and the honest fallback
+ *    for a `requestDto` this code cannot introspect (a thinned projection), because refusing to
+ *    guess returns the behaviour the operation had before.
+ *
+ * `POPOVER` and `INLINE` are never DERIVED, only authored. Both are claims about the surrounding
+ * context — that the trigger is anchored and visible, that the element being acted on is a row in a
+ * list — which this function cannot see from the operation alone. Guessing them would put chrome in
+ * places it cannot render.
+ */
+export declare function resolveResourceOperationActionPresentation(operation: ResourceOperationSemanticsLike): ResourceOperationActionPresentation;
+/**
+ * Does this presentation reach the NAVIGATION layer, or does the action layer own it end to end?
+ *
+ * `MODAL` and `PAGE` are destinations. `DIRECT`, `POPOVER` and `INLINE` are not: nothing is pushed,
+ * no zone changes, and there is nothing for a back button to pop — routing them through navigation
+ * would mint zone entries for chrome that does not live in a zone.
+ *
+ * `INLINE` is the one worth explaining, because `NavigationTransition.INPLACE` exists and looks like
+ * its home. It is not: element-level hosting uses NONE of what navigation provides — no zone, no
+ * stack entry, no appearance, no lifecycle modifier — and routing it there is exactly why that
+ * transition has never done what its docstring promises (it falls through to a zone REPLACE). The
+ * host lives with the elements instead; see `InPlaceOperationContext`.
+ */
+export declare function actionPresentationNavigates(presentation: ResourceOperationActionPresentation): boolean;
+/**
+ * The navigation transition an action presentation is an alias FOR.
+ *
+ * `PAGE` maps to `undefined` deliberately, and it is the most important row: a page is not a
+ * transition, it is "let the ordinary chain answer". Returning `PUSH` here would flatten every
+ * app's zone transitions, viewport overrides and relationship defaults into one verb — the axis
+ * would stop being an alias and start being an override, which is the failure mode this design
+ * exists to avoid.
+ *
+ * `POPOVER` maps to `OVERLAY` — its DEGRADE target, not its normal path. A popover normally never
+ * reaches navigation ({@link actionPresentationNavigates} is false for it), but a host that cannot
+ * ANCHOR one — an action collapsed into an overflow menu or nested in a subgroup — has to present
+ * the same input somewhere, and the honest substitute for "a small panel next to the button" is an
+ * overlay. Leaving it `undefined` would send that action to the ordinary chain and produce a full
+ * PAGE for the presentation that asked for the least chrome of all.
+ *
+ * `DIRECT` maps to `undefined` because it collects nothing: there is no input to relocate.
+ */
+export declare function resolveActionPresentationTransition(presentation: ResourceOperationActionPresentation): NavigationTransition | undefined;
 export declare function resolveResourceOperationLayoutKind(operation: ResourceOperationSemanticsLike): ResourceOperationLayoutKind;
 export declare function pickPreferredOperationForCoreSemantic<T extends ResourceOperationSemanticsLike>(operations: readonly T[], coreOperation: CoreResourceOperation, options?: {
     requireAddressable?: boolean;

package/dist/esm/core/resources/operation-semantics.frontend.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operation-semantics.frontend.utils.d.ts","sourceRoot":"","sources":["../../../../src/core/resources/operation-semantics.frontend.utils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"operation-semantics.frontend.utils.d.ts","sourceRoot":"","sources":["../../../../../src/core/resources/operation-semantics.frontend.utils.ts"],"names":[],"mappings":"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"}