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

package/dist/esm/core/loading/loading-policy.frontend.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loading-policy.frontend.schemas.d.ts","sourceRoot":"","sources":["../../../../src/core/loading/loading-policy.frontend.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAChF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAGtE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,EAAE,OAAO,CAAC,MAAM,CAAC,yBAAyB,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC,CAMxG,CAAC"}
+{"version":3,"file":"loading-policy.frontend.schemas.d.ts","sourceRoot":"","sources":["../../../../../src/core/loading/loading-policy.frontend.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAChF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAGtE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,EAAE,OAAO,CAAC,MAAM,CAAC,yBAAyB,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC,CAMxG,CAAC"}

package/dist/esm/core/loading/loading-policy.frontend.schemas.js

@@ -18,4 +18,4 @@ export const CATEGORY_LOADING_DEFAULTS = {
     [FrontendComponentCategory.APPLICATION_LEVEL_COMPONENTS]: { initialLoad: LoadingTreatment.SKELETON, refresh: LoadingTreatment.HIDDEN },
     [FrontendComponentCategory.PUBLIC_LAYOUTS]: { initialLoad: LoadingTreatment.SPINNER, refresh: LoadingTreatment.SPINNER },
 };
-//# sourceMappingURL=loading-policy.frontend.schemas.js.map
+//# sourceMappingURL=loading-policy.frontend.schemas.js.map

package/dist/esm/core/loading/loading-policy.frontend.schemas.js.map

@@ -1 +1 @@
-{"version":3,"file":"loading-policy.frontend.schemas.js","sourceRoot":"","sources":["../../../../src/core/loading/loading-policy.frontend.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAEhF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAEpE;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAuE;IAC3G,CAAC,yBAAyB,CAAC,iBAAiB,CAAC,EAAa,EAAE,WAAW,EAAE,gBAAgB,CAAC,QAAQ,EAAG,OAAO,EAAE,gBAAgB,CAAC,eAAe,EAAE;IAChJ,CAAC,yBAAyB,CAAC,gBAAgB,CAAC,EAAc,EAAE,WAAW,EAAE,gBAAgB,CAAC,QAAQ,EAAG,OAAO,EAAE,gBAAgB,CAAC,eAAe,EAAE;IAChJ,CAAC,yBAAyB,CAAC,gBAAgB,CAAC,EAAc,EAAE,WAAW,EAAE,gBAAgB,CAAC,QAAQ,EAAG,OAAO,EAAE,gBAAgB,CAAC,eAAe,EAAE;IAChJ,CAAC,yBAAyB,CAAC,4BAA4B,CAAC,EAAE,EAAE,WAAW,EAAE,gBAAgB,CAAC,QAAQ,EAAG,OAAO,EAAE,gBAAgB,CAAC,MAAM,EAAE;IACvI,CAAC,yBAAyB,CAAC,cAAc,CAAC,EAAiB,EAAE,WAAW,EAAE,gBAAgB,CAAC,OAAO,EAAI,OAAO,EAAE,gBAAgB,CAAC,OAAO,EAAE;CAC1I,CAAC"}
+{"version":3,"file":"loading-policy.frontend.schemas.js","sourceRoot":"","sources":["../../../../../src/core/loading/loading-policy.frontend.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAEhF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAEpE;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAuE;IAC3G,CAAC,yBAAyB,CAAC,iBAAiB,CAAC,EAAa,EAAE,WAAW,EAAE,gBAAgB,CAAC,QAAQ,EAAG,OAAO,EAAE,gBAAgB,CAAC,eAAe,EAAE;IAChJ,CAAC,yBAAyB,CAAC,gBAAgB,CAAC,EAAc,EAAE,WAAW,EAAE,gBAAgB,CAAC,QAAQ,EAAG,OAAO,EAAE,gBAAgB,CAAC,eAAe,EAAE;IAChJ,CAAC,yBAAyB,CAAC,gBAAgB,CAAC,EAAc,EAAE,WAAW,EAAE,gBAAgB,CAAC,QAAQ,EAAG,OAAO,EAAE,gBAAgB,CAAC,eAAe,EAAE;IAChJ,CAAC,yBAAyB,CAAC,4BAA4B,CAAC,EAAE,EAAE,WAAW,EAAE,gBAAgB,CAAC,QAAQ,EAAG,OAAO,EAAE,gBAAgB,CAAC,MAAM,EAAE;IACvI,CAAC,yBAAyB,CAAC,cAAc,CAAC,EAAiB,EAAE,WAAW,EAAE,gBAAgB,CAAC,OAAO,EAAI,OAAO,EAAE,gBAAgB,CAAC,OAAO,EAAE;CAC1I,CAAC","sourcesContent":["import { FrontendComponentCategory } from '@wildo-ai/presets-components-models';\nimport type { LoadingPolicy } from './loading-types.frontend.schemas';\nimport { LoadingTreatment } from './loading-types.frontend.schemas';\n\n/**\n * Day-1 category defaults for loading policy resolution.\n *\n * Categories NOT listed (`APP_LAYOUTS`, `LOW_LEVEL_COMPONENTS`, `GUIDANCE`,\n * `PROGRESSION`, `LIFECYCLE`) have **no default** — their presets either\n * don't load data (primitives) or have specialized loading flows.\n * Presets in those categories must provide explicit overrides when using\n * `resolveLoadingPolicy`; omitting the category is intentional.\n *\n * @see loading-system-architecture.md §2.5\n */\nexport const CATEGORY_LOADING_DEFAULTS: Partial<Record<FrontendComponentCategory, Partial<LoadingPolicy>>> = {\n  [FrontendComponentCategory.RESOURCES_LAYOUTS]:            { initialLoad: LoadingTreatment.SKELETON,  refresh: LoadingTreatment.OPACITY_OVERLAY },\n  [FrontendComponentCategory.RESOURCES_FIELDS]:             { initialLoad: LoadingTreatment.SKELETON,  refresh: LoadingTreatment.OPACITY_OVERLAY },\n  [FrontendComponentCategory.HIGH_LEVEL_VIEWS]:             { initialLoad: LoadingTreatment.SKELETON,  refresh: LoadingTreatment.OPACITY_OVERLAY },\n  [FrontendComponentCategory.APPLICATION_LEVEL_COMPONENTS]: { initialLoad: LoadingTreatment.SKELETON,  refresh: LoadingTreatment.HIDDEN },\n  [FrontendComponentCategory.PUBLIC_LAYOUTS]:                { initialLoad: LoadingTreatment.SPINNER,   refresh: LoadingTreatment.SPINNER },\n};\n"]}

package/dist/esm/core/loading/loading-scope.frontend.utils.d.ts

@@ -1,4 +1,6 @@
-import type { LoadingScope } from './loading-types.frontend.schemas.js';
+import type { LoadingScope } from './loading-types.frontend.schemas';
+import { AppLoadingIdentifier, ContextLoadingIdentifier } from './loading-types.frontend.schemas';
+import type { CoreResourceOperation } from '@wildo-ai/saas-models';
 /**
  * Builds a deterministic string key from a LoadingScope.
  * Used as Map keys in the loading state aggregator.
@@ -10,4 +12,38 @@ import type { LoadingScope } from './loading-types.frontend.schemas.js';
  * Consumers must use the same scope shape to match — no fuzzy matching.
  */
 export declare function buildLoadingScopeKey(scope: LoadingScope): string;
+/**
+ * L-3: typed loading-scope builders.
+ *
+ * These narrow the inputs accepted by `LoadingScope`'s open-world string
+ * fields, making it harder to typo or forget a required identifier:
+ *
+ * - `buildResourceLoadingScope` requires `resourceType` and `operation`. The
+ *   `operation` field accepts `CoreResourceOperation` (enum, autocompleted)
+ *   or a domain operation identifier string (custom resources / variants).
+ * - `buildAppLoadingScope` requires an `AppLoadingIdentifier` enum value, so
+ *   Tier-1 (APPLICATION) callers can't drift to ad-hoc strings.
+ *
+ * Existing callers can keep building the LoadingScope literal directly; these
+ * helpers are an opt-in safety layer used in new/refactored sites.
+ */
+export declare function buildResourceLoadingScope<TOperation extends string = CoreResourceOperation | string>(args: {
+    resourceType: string;
+    operation: TOperation;
+    discriminator?: string;
+}): LoadingScope;
+export declare function buildAppLoadingScope(identifier: AppLoadingIdentifier | `init:${string}` | `app:${string}`): LoadingScope;
+/**
+ * L-2.b: typed builder for **Tier-2 context** loading scopes.
+ *
+ * Use this from the four canonical contexts (billing, flows-actors,
+ * progression, lifecycle) — and from any future context that opts into
+ * publishing its loading state through `LoadingContext`. The narrowed
+ * `ContextLoadingIdentifier` enum prevents drift to ad-hoc identifier strings.
+ *
+ * Pair with `useEmitLoadingScope` for the canonical fire/end pattern, or
+ * call `fireLoading({ ...scope }, { tier: LoadingTier.COMPONENT, phase })`
+ * + `endLoading({ ...scope }, { tier: LoadingTier.COMPONENT })` directly.
+ */
+export declare function buildContextLoadingScope(identifier: ContextLoadingIdentifier): LoadingScope;
 //# sourceMappingURL=loading-scope.frontend.utils.d.ts.map

package/dist/esm/core/loading/loading-scope.frontend.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loading-scope.frontend.utils.d.ts","sourceRoot":"","sources":["../../../../src/core/loading/loading-scope.frontend.utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAErE;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAIhE"}
+{"version":3,"file":"loading-scope.frontend.utils.d.ts","sourceRoot":"","sources":["../../../../../src/core/loading/loading-scope.frontend.utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAClG,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAEnE;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAIhE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,SAAS,MAAM,GAAG,qBAAqB,GAAG,MAAM,EAAE,IAAI,EAAE;IAC1G,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,UAAU,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,YAAY,CAMf;AAED,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,oBAAoB,GAAG,QAAQ,MAAM,EAAE,GAAG,OAAO,MAAM,EAAE,GAAG,YAAY,CAExH;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,wBAAwB,GAAG,YAAY,CAE3F"}

package/dist/esm/core/loading/loading-scope.frontend.utils.js

@@ -14,4 +14,44 @@ export function buildLoadingScopeKey(scope) {
     const parts = [scope.resourceType, scope.operation, scope.discriminator].filter(Boolean);
     return parts.join(':');
 }
-//# sourceMappingURL=loading-scope.frontend.utils.js.map
+/**
+ * L-3: typed loading-scope builders.
+ *
+ * These narrow the inputs accepted by `LoadingScope`'s open-world string
+ * fields, making it harder to typo or forget a required identifier:
+ *
+ * - `buildResourceLoadingScope` requires `resourceType` and `operation`. The
+ *   `operation` field accepts `CoreResourceOperation` (enum, autocompleted)
+ *   or a domain operation identifier string (custom resources / variants).
+ * - `buildAppLoadingScope` requires an `AppLoadingIdentifier` enum value, so
+ *   Tier-1 (APPLICATION) callers can't drift to ad-hoc strings.
+ *
+ * Existing callers can keep building the LoadingScope literal directly; these
+ * helpers are an opt-in safety layer used in new/refactored sites.
+ */
+export function buildResourceLoadingScope(args) {
+    return {
+        resourceType: args.resourceType,
+        operation: String(args.operation),
+        discriminator: args.discriminator,
+    };
+}
+export function buildAppLoadingScope(identifier) {
+    return { customIdentifier: identifier };
+}
+/**
+ * L-2.b: typed builder for **Tier-2 context** loading scopes.
+ *
+ * Use this from the four canonical contexts (billing, flows-actors,
+ * progression, lifecycle) — and from any future context that opts into
+ * publishing its loading state through `LoadingContext`. The narrowed
+ * `ContextLoadingIdentifier` enum prevents drift to ad-hoc identifier strings.
+ *
+ * Pair with `useEmitLoadingScope` for the canonical fire/end pattern, or
+ * call `fireLoading({ ...scope }, { tier: LoadingTier.COMPONENT, phase })`
+ * + `endLoading({ ...scope }, { tier: LoadingTier.COMPONENT })` directly.
+ */
+export function buildContextLoadingScope(identifier) {
+    return { customIdentifier: identifier };
+}
+//# sourceMappingURL=loading-scope.frontend.utils.js.map

package/dist/esm/core/loading/loading-scope.frontend.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"loading-scope.frontend.utils.js","sourceRoot":"","sources":["../../../../src/core/loading/loading-scope.frontend.utils.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAmB;IACtD,IAAI,KAAK,CAAC,gBAAgB;QAAE,OAAO,UAAU,KAAK,CAAC,gBAAgB,EAAE,CAAC;IACtE,MAAM,KAAK,GAAG,CAAC,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACzF,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACzB,CAAC"}
+{"version":3,"file":"loading-scope.frontend.utils.js","sourceRoot":"","sources":["../../../../../src/core/loading/loading-scope.frontend.utils.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAmB;IACtD,IAAI,KAAK,CAAC,gBAAgB;QAAE,OAAO,UAAU,KAAK,CAAC,gBAAgB,EAAE,CAAC;IACtE,MAAM,KAAK,GAAG,CAAC,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACzF,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACzB,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,yBAAyB,CAA6D,IAIrG;IACC,OAAO;QACL,YAAY,EAAE,IAAI,CAAC,YAAY;QAC/B,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC;QACjC,aAAa,EAAE,IAAI,CAAC,aAAa;KAClC,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,UAAqE;IACxG,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC;AAC1C,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,wBAAwB,CAAC,UAAoC;IAC3E,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC;AAC1C,CAAC","sourcesContent":["import type { LoadingScope } from './loading-types.frontend.schemas';\nimport { AppLoadingIdentifier, ContextLoadingIdentifier } from './loading-types.frontend.schemas';\nimport type { CoreResourceOperation } from '@wildo-ai/saas-models';\n\n/**\n * Builds a deterministic string key from a LoadingScope.\n * Used as Map keys in the loading state aggregator.\n *\n * Key format:\n * - Custom: `custom:{identifier}`\n * - Resource: `{resourceType}:{operation}` or `{resourceType}:{operation}:{discriminator}`\n *\n * Consumers must use the same scope shape to match — no fuzzy matching.\n */\nexport function buildLoadingScopeKey(scope: LoadingScope): string {\n  if (scope.customIdentifier) return `custom:${scope.customIdentifier}`;\n  const parts = [scope.resourceType, scope.operation, scope.discriminator].filter(Boolean);\n  return parts.join(':');\n}\n\n/**\n * L-3: typed loading-scope builders.\n *\n * These narrow the inputs accepted by `LoadingScope`'s open-world string\n * fields, making it harder to typo or forget a required identifier:\n *\n * - `buildResourceLoadingScope` requires `resourceType` and `operation`. The\n *   `operation` field accepts `CoreResourceOperation` (enum, autocompleted)\n *   or a domain operation identifier string (custom resources / variants).\n * - `buildAppLoadingScope` requires an `AppLoadingIdentifier` enum value, so\n *   Tier-1 (APPLICATION) callers can't drift to ad-hoc strings.\n *\n * Existing callers can keep building the LoadingScope literal directly; these\n * helpers are an opt-in safety layer used in new/refactored sites.\n */\nexport function buildResourceLoadingScope<TOperation extends string = CoreResourceOperation | string>(args: {\n  resourceType: string;\n  operation: TOperation;\n  discriminator?: string;\n}): LoadingScope {\n  return {\n    resourceType: args.resourceType,\n    operation: String(args.operation),\n    discriminator: args.discriminator,\n  };\n}\n\nexport function buildAppLoadingScope(identifier: AppLoadingIdentifier | `init:${string}` | `app:${string}`): LoadingScope {\n  return { customIdentifier: identifier };\n}\n\n/**\n * L-2.b: typed builder for **Tier-2 context** loading scopes.\n *\n * Use this from the four canonical contexts (billing, flows-actors,\n * progression, lifecycle) — and from any future context that opts into\n * publishing its loading state through `LoadingContext`. The narrowed\n * `ContextLoadingIdentifier` enum prevents drift to ad-hoc identifier strings.\n *\n * Pair with `useEmitLoadingScope` for the canonical fire/end pattern, or\n * call `fireLoading({ ...scope }, { tier: LoadingTier.COMPONENT, phase })`\n * + `endLoading({ ...scope }, { tier: LoadingTier.COMPONENT })` directly.\n */\nexport function buildContextLoadingScope(identifier: ContextLoadingIdentifier): LoadingScope {\n  return { customIdentifier: identifier };\n}\n"]}

package/dist/esm/core/loading/loading-types.frontend.schemas.d.ts

@@ -20,6 +20,38 @@ export declare enum AppLoadingIdentifier {
     /** Translations reload triggered by a language change */
     I18N_LANGUAGE_CHANGE = "i18n:language-change"
 }
+/**
+ * Well-known custom loading identifiers for Tier 2 (COMPONENT) **context**
+ * providers — i.e. high-level frontend-lib contexts (billing, flows-actors,
+ * progression, lifecycle, …) that own their own fetch lifecycle but want to
+ * publish that lifecycle through `LoadingContext` so unrelated components can
+ * observe it via `useComponentLoading({ customIdentifier })`.
+ *
+ * **L-2.b decision (2026-04-21): emit via the LoadingContext event bus**
+ * rather than expose ad-hoc `useXxxLoadingScope()` hooks. Rationale:
+ * - `LoadingContext` is already the single source of truth for both
+ *   `LoadingGate` and `useComponentLoading`; parallel hooks would fragment
+ *   the model and force every cross-cutting consumer to learn N adapters.
+ * - The infrastructure already exists (LOADING_CUSTOM_*` events with
+ *   `tier: COMPONENT`); no schema change needed.
+ * - Contexts keep exposing their own `isLoading` for direct consumers
+ *   (back-compat), but ALSO call `fireLoading`/`endLoading` so that
+ *   downstream sites can wrap content in a `LoadingGate`/`useComponentLoading`
+ *   without coupling to the context.
+ *
+ * Naming convention: `app:<domain>` (lowercase, kebab-case for multi-word).
+ * Add a new entry here when promoting a context to publish its loading state.
+ */
+export declare enum ContextLoadingIdentifier {
+    /** BillingContext: billing-state fetch lifecycle */
+    BILLING_STATE = "app:billing:state",
+    /** FlowsActorsContext: flows + actors registry fetch lifecycle */
+    FLOWS_ACTORS = "app:flows-actors",
+    /** GuidanceContext: progression / guidance graph fetch lifecycle */
+    PROGRESSION = "app:progression",
+    /** ExecutionRuntimeContext: lifecycle/runtime state fetch */
+    LIFECYCLE = "app:lifecycle"
+}
 /** Which tier a loading event belongs to */
 export declare enum LoadingTier {
     /** App-level: gates the entire application (init steps, language change) */

package/dist/esm/core/loading/loading-types.frontend.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loading-types.frontend.schemas.d.ts","sourceRoot":"","sources":["../../../../src/core/loading/loading-types.frontend.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;GAKG;AACH,oBAAY,oBAAoB;IAC9B,+CAA+C;IAC/C,SAAS,cAAc;IACvB,yDAAyD;IACzD,oBAAoB,yBAAyB;CAC9C;AAED,4CAA4C;AAC5C,oBAAY,WAAW;IACrB,4EAA4E;IAC5E,WAAW,gBAAgB;IAC3B,4EAA4E;IAC5E,SAAS,cAAc;CACxB;AAED,iEAAiE;AACjE,oBAAY,YAAY;IACtB,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB;AAED;;;;;GAKG;AACH,oBAAY,gBAAgB;IAC1B,0EAA0E;IAC1E,QAAQ,aAAa;IACrB,uEAAuE;IACvE,OAAO,YAAY;IACnB,wEAAwE;IACxE,eAAe,oBAAoB;IACnC,gDAAgD;IAChD,MAAM,WAAW;IACjB,wDAAwD;IACxD,SAAS,cAAc;IACvB,uEAAuE;IACvE,WAAW,gBAAgB;IAC3B,gEAAgE;IAChE,MAAM,WAAW;CAClB;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6FAA6F;IAC7F,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gEAAgE;IAChE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,gBAAgB,CAAC;IAC9B,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,OAAO,OAAO,EAAE,SAAS,CAAC;IAC9E,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,iDAAiD;AACjD,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,YAAY,CAAC;IACpB,KAAK,EAAE,YAAY,CAAC;CACrB;AAED,uDAAuD;AACvD,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,YAAY,EAAE,CAAC;IAC7B,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC;IAC5B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,aAAa,EAAE,OAAO,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,YAAY,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,6EAA6E;AAC7E,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,WAAW,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB"}
+{"version":3,"file":"loading-types.frontend.schemas.d.ts","sourceRoot":"","sources":["../../../../../src/core/loading/loading-types.frontend.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;GAKG;AACH,oBAAY,oBAAoB;IAC9B,+CAA+C;IAC/C,SAAS,cAAc;IACvB,yDAAyD;IACzD,oBAAoB,yBAAyB;CAC9C;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,oBAAY,wBAAwB;IAClC,oDAAoD;IACpD,aAAa,sBAAsB;IACnC,kEAAkE;IAClE,YAAY,qBAAqB;IACjC,oEAAoE;IACpE,WAAW,oBAAoB;IAC/B,6DAA6D;IAC7D,SAAS,kBAAkB;CAC5B;AAED,4CAA4C;AAC5C,oBAAY,WAAW;IACrB,4EAA4E;IAC5E,WAAW,gBAAgB;IAC3B,4EAA4E;IAC5E,SAAS,cAAc;CACxB;AAED,iEAAiE;AACjE,oBAAY,YAAY;IACtB,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB;AAED;;;;;GAKG;AACH,oBAAY,gBAAgB;IAC1B,0EAA0E;IAC1E,QAAQ,aAAa;IACrB,uEAAuE;IACvE,OAAO,YAAY;IACnB,wEAAwE;IACxE,eAAe,oBAAoB;IACnC,gDAAgD;IAChD,MAAM,WAAW;IACjB,wDAAwD;IACxD,SAAS,cAAc;IACvB,uEAAuE;IACvE,WAAW,gBAAgB;IAC3B,gEAAgE;IAChE,MAAM,WAAW;CAClB;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6FAA6F;IAC7F,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gEAAgE;IAChE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,gBAAgB,CAAC;IAC9B,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,OAAO,OAAO,EAAE,SAAS,CAAC;IAC9E,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,iDAAiD;AACjD,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,YAAY,CAAC;IACpB,KAAK,EAAE,YAAY,CAAC;CACrB;AAED,uDAAuD;AACvD,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,YAAY,EAAE,CAAC;IAC7B,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC;IAC5B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,aAAa,EAAE,OAAO,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,YAAY,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,6EAA6E;AAC7E,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,WAAW,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/esm/core/loading/loading-types.frontend.schemas.js

@@ -21,6 +21,39 @@ export var AppLoadingIdentifier;
     /** Translations reload triggered by a language change */
     AppLoadingIdentifier["I18N_LANGUAGE_CHANGE"] = "i18n:language-change";
 })(AppLoadingIdentifier || (AppLoadingIdentifier = {}));
+/**
+ * Well-known custom loading identifiers for Tier 2 (COMPONENT) **context**
+ * providers — i.e. high-level frontend-lib contexts (billing, flows-actors,
+ * progression, lifecycle, …) that own their own fetch lifecycle but want to
+ * publish that lifecycle through `LoadingContext` so unrelated components can
+ * observe it via `useComponentLoading({ customIdentifier })`.
+ *
+ * **L-2.b decision (2026-04-21): emit via the LoadingContext event bus**
+ * rather than expose ad-hoc `useXxxLoadingScope()` hooks. Rationale:
+ * - `LoadingContext` is already the single source of truth for both
+ *   `LoadingGate` and `useComponentLoading`; parallel hooks would fragment
+ *   the model and force every cross-cutting consumer to learn N adapters.
+ * - The infrastructure already exists (LOADING_CUSTOM_*` events with
+ *   `tier: COMPONENT`); no schema change needed.
+ * - Contexts keep exposing their own `isLoading` for direct consumers
+ *   (back-compat), but ALSO call `fireLoading`/`endLoading` so that
+ *   downstream sites can wrap content in a `LoadingGate`/`useComponentLoading`
+ *   without coupling to the context.
+ *
+ * Naming convention: `app:<domain>` (lowercase, kebab-case for multi-word).
+ * Add a new entry here when promoting a context to publish its loading state.
+ */
+export var ContextLoadingIdentifier;
+(function (ContextLoadingIdentifier) {
+    /** BillingContext: billing-state fetch lifecycle */
+    ContextLoadingIdentifier["BILLING_STATE"] = "app:billing:state";
+    /** FlowsActorsContext: flows + actors registry fetch lifecycle */
+    ContextLoadingIdentifier["FLOWS_ACTORS"] = "app:flows-actors";
+    /** GuidanceContext: progression / guidance graph fetch lifecycle */
+    ContextLoadingIdentifier["PROGRESSION"] = "app:progression";
+    /** ExecutionRuntimeContext: lifecycle/runtime state fetch */
+    ContextLoadingIdentifier["LIFECYCLE"] = "app:lifecycle";
+})(ContextLoadingIdentifier || (ContextLoadingIdentifier = {}));
 /** Which tier a loading event belongs to */
 export var LoadingTier;
 (function (LoadingTier) {
@@ -58,4 +91,4 @@ export var LoadingTreatment;
     /** Custom renderer provided via LoadingPolicy.customRenderer */
     LoadingTreatment["CUSTOM"] = "CUSTOM";
 })(LoadingTreatment || (LoadingTreatment = {}));
-//# sourceMappingURL=loading-types.frontend.schemas.js.map
+//# sourceMappingURL=loading-types.frontend.schemas.js.map

package/dist/esm/core/loading/loading-types.frontend.schemas.js.map

@@ -1 +1 @@
-{"version":3,"file":"loading-types.frontend.schemas.js","sourceRoot":"","sources":["../../../../src/core/loading/loading-types.frontend.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;GAKG;AACH,MAAM,CAAN,IAAY,oBAKX;AALD,WAAY,oBAAoB;IAC9B,+CAA+C;IAC/C,+CAAuB,CAAA;IACvB,yDAAyD;IACzD,qEAA6C,CAAA;AAC/C,CAAC,EALW,oBAAoB,KAApB,oBAAoB,QAK/B;AAED,4CAA4C;AAC5C,MAAM,CAAN,IAAY,WAKX;AALD,WAAY,WAAW;IACrB,4EAA4E;IAC5E,0CAA2B,CAAA;IAC3B,4EAA4E;IAC5E,sCAAuB,CAAA;AACzB,CAAC,EALW,WAAW,KAAX,WAAW,QAKtB;AAED,iEAAiE;AACjE,MAAM,CAAN,IAAY,YAGX;AAHD,WAAY,YAAY;IACtB,mCAAmB,CAAA;IACnB,mCAAmB,CAAA;AACrB,CAAC,EAHW,YAAY,KAAZ,YAAY,QAGvB;AAED;;;;;GAKG;AACH,MAAM,CAAN,IAAY,gBAeX;AAfD,WAAY,gBAAgB;IAC1B,0EAA0E;IAC1E,yCAAqB,CAAA;IACrB,uEAAuE;IACvE,uCAAmB,CAAA;IACnB,wEAAwE;IACxE,uDAAmC,CAAA;IACnC,gDAAgD;IAChD,qCAAiB,CAAA;IACjB,wDAAwD;IACxD,2CAAuB,CAAA;IACvB,uEAAuE;IACvE,+CAA2B,CAAA;IAC3B,gEAAgE;IAChE,qCAAiB,CAAA;AACnB,CAAC,EAfW,gBAAgB,KAAhB,gBAAgB,QAe3B"}
+{"version":3,"file":"loading-types.frontend.schemas.js","sourceRoot":"","sources":["../../../../../src/core/loading/loading-types.frontend.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;GAKG;AACH,MAAM,CAAN,IAAY,oBAKX;AALD,WAAY,oBAAoB;IAC9B,+CAA+C;IAC/C,+CAAuB,CAAA;IACvB,yDAAyD;IACzD,qEAA6C,CAAA;AAC/C,CAAC,EALW,oBAAoB,KAApB,oBAAoB,QAK/B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAN,IAAY,wBASX;AATD,WAAY,wBAAwB;IAClC,oDAAoD;IACpD,+DAAmC,CAAA;IACnC,kEAAkE;IAClE,6DAAiC,CAAA;IACjC,oEAAoE;IACpE,2DAA+B,CAAA;IAC/B,6DAA6D;IAC7D,uDAA2B,CAAA;AAC7B,CAAC,EATW,wBAAwB,KAAxB,wBAAwB,QASnC;AAED,4CAA4C;AAC5C,MAAM,CAAN,IAAY,WAKX;AALD,WAAY,WAAW;IACrB,4EAA4E;IAC5E,0CAA2B,CAAA;IAC3B,4EAA4E;IAC5E,sCAAuB,CAAA;AACzB,CAAC,EALW,WAAW,KAAX,WAAW,QAKtB;AAED,iEAAiE;AACjE,MAAM,CAAN,IAAY,YAGX;AAHD,WAAY,YAAY;IACtB,mCAAmB,CAAA;IACnB,mCAAmB,CAAA;AACrB,CAAC,EAHW,YAAY,KAAZ,YAAY,QAGvB;AAED;;;;;GAKG;AACH,MAAM,CAAN,IAAY,gBAeX;AAfD,WAAY,gBAAgB;IAC1B,0EAA0E;IAC1E,yCAAqB,CAAA;IACrB,uEAAuE;IACvE,uCAAmB,CAAA;IACnB,wEAAwE;IACxE,uDAAmC,CAAA;IACnC,gDAAgD;IAChD,qCAAiB,CAAA;IACjB,wDAAwD;IACxD,2CAAuB,CAAA;IACvB,uEAAuE;IACvE,+CAA2B,CAAA;IAC3B,gEAAgE;IAChE,qCAAiB,CAAA;AACnB,CAAC,EAfW,gBAAgB,KAAhB,gBAAgB,QAe3B","sourcesContent":["/**\n * Loading System Type Definitions\n *\n * Foundation types for the 3-tier loading architecture.\n * See .cursor/plans/loading-system-architecture.md for full design.\n *\n * Tier 1 (APPLICATION): Gates the entire UI — init steps, language change, org switch.\n * Tier 2 (COMPONENT): Per-scope loading managed centrally — enables cross-component awareness.\n * Tier 3 (ACTION): Local to the component — button spinners, inline saves. Not tracked here.\n */\n\n/**\n * Well-known custom loading identifiers for Tier 1 (APPLICATION) events.\n *\n * Used as `customIdentifier` in LoadingScope and as `identifier` in\n * LOADING_CUSTOM_START/END event payloads.\n */\nexport enum AppLoadingIdentifier {\n  /** Initial translations load on app startup */\n  INIT_I18N = 'init:i18n',\n  /** Translations reload triggered by a language change */\n  I18N_LANGUAGE_CHANGE = 'i18n:language-change',\n}\n\n/**\n * Well-known custom loading identifiers for Tier 2 (COMPONENT) **context**\n * providers — i.e. high-level frontend-lib contexts (billing, flows-actors,\n * progression, lifecycle, …) that own their own fetch lifecycle but want to\n * publish that lifecycle through `LoadingContext` so unrelated components can\n * observe it via `useComponentLoading({ customIdentifier })`.\n *\n * **L-2.b decision (2026-04-21): emit via the LoadingContext event bus**\n * rather than expose ad-hoc `useXxxLoadingScope()` hooks. Rationale:\n * - `LoadingContext` is already the single source of truth for both\n *   `LoadingGate` and `useComponentLoading`; parallel hooks would fragment\n *   the model and force every cross-cutting consumer to learn N adapters.\n * - The infrastructure already exists (LOADING_CUSTOM_*` events with\n *   `tier: COMPONENT`); no schema change needed.\n * - Contexts keep exposing their own `isLoading` for direct consumers\n *   (back-compat), but ALSO call `fireLoading`/`endLoading` so that\n *   downstream sites can wrap content in a `LoadingGate`/`useComponentLoading`\n *   without coupling to the context.\n *\n * Naming convention: `app:<domain>` (lowercase, kebab-case for multi-word).\n * Add a new entry here when promoting a context to publish its loading state.\n */\nexport enum ContextLoadingIdentifier {\n  /** BillingContext: billing-state fetch lifecycle */\n  BILLING_STATE = 'app:billing:state',\n  /** FlowsActorsContext: flows + actors registry fetch lifecycle */\n  FLOWS_ACTORS = 'app:flows-actors',\n  /** GuidanceContext: progression / guidance graph fetch lifecycle */\n  PROGRESSION = 'app:progression',\n  /** ExecutionRuntimeContext: lifecycle/runtime state fetch */\n  LIFECYCLE = 'app:lifecycle',\n}\n\n/** Which tier a loading event belongs to */\nexport enum LoadingTier {\n  /** App-level: gates the entire application (init steps, language change) */\n  APPLICATION = 'application',\n  /** Component-level: managed centrally, enables cross-component awareness */\n  COMPONENT = 'component',\n}\n\n/** Whether this is a first load or a refresh of existing data */\nexport enum LoadingPhase {\n  INITIAL = 'initial',\n  REFRESH = 'refresh',\n}\n\n/**\n * Visual treatment for loading states.\n *\n * Used by LoadingPolicy to determine what the user sees while content loads.\n * SKELETON and OPACITY_OVERLAY preserve layout stability; SPINNER and FULL_SCREEN do not.\n */\nexport enum LoadingTreatment {\n  /** Placeholder shapes matching content layout — best for initial loads */\n  SKELETON = 'SKELETON',\n  /** Centered spinner — use when layout is unknown or for short waits */\n  SPINNER = 'SPINNER',\n  /** Semi-transparent overlay on existing content — best for refreshes */\n  OPACITY_OVERLAY = 'OPACITY_OVERLAY',\n  /** display: none — component hidden entirely */\n  HIDDEN = 'HIDDEN',\n  /** visibility: hidden — space reserved but invisible */\n  INVISIBLE = 'INVISIBLE',\n  /** Full-screen overlay blocking all interaction — app-level loading */\n  FULL_SCREEN = 'FULL_SCREEN',\n  /** Custom renderer provided via LoadingPolicy.customRenderer */\n  CUSTOM = 'CUSTOM',\n}\n\n/**\n * Identifies what is loading — resource operation or custom identifier.\n *\n * At least one of `resourceType`+`operation` or `customIdentifier` must be provided.\n * The scope is serialized to a string key via `buildLoadingScopeKey()` for Map lookups.\n */\nexport interface LoadingScope {\n  resourceType?: string;\n  operation?: string;\n  /** Distinguishes multiple instances of the same resource+operation (e.g., inline editors) */\n  discriminator?: string;\n  /** For non-resource loading (e.g., 'init:auth', 'init:i18n') */\n  customIdentifier?: string;\n}\n\n/**\n * Policy that determines how loading is rendered.\n *\n * Resolved by resolveLoadingPolicy — 2-layer for day 1:\n * 1. Category defaults (resource lists → SKELETON, actions → SPINNER, etc.)\n * 2. Explicit override via LoadingGate props\n */\nexport interface LoadingPolicy {\n  initialLoad: LoadingTreatment;\n  refresh?: LoadingTreatment;\n  customRenderer?: (context: LoadingRenderContext) => import('react').ReactNode;\n  disableInteraction?: boolean;\n  skeletonSchema?: unknown;\n}\n\n/** Context passed to custom loading renderers */\nexport interface LoadingRenderContext {\n  phase: LoadingPhase;\n  scope: LoadingScope;\n}\n\n/** Context passed to error renderers on LoadingGate */\nexport interface LoadingErrorContext {\n  failedScopes: LoadingScope[];\n  reason: 'timeout' | 'error';\n  retry: () => void;\n  error?: unknown;\n}\n\n/**\n * Internal state for a single loading scope in the LoadingContext aggregator.\n *\n * activeCount tracks concurrent requests for the same scope (e.g., rapid LIST refreshes).\n * isLoading is true when activeCount > 0.\n */\nexport interface ComponentLoadingState {\n  hasLoadedOnce: boolean;\n  isLoading: boolean;\n  phase: LoadingPhase;\n  activeCount: number;\n}\n\n/** Active app-level loading source — exposed for debugging and UI display */\nexport interface LoadingSource {\n  identifier: string;\n  tier: LoadingTier;\n  startedAt: number;\n}\n"]}

package/dist/esm/core/loading/resolveLoadingPolicy.d.ts

@@ -1,5 +1,5 @@
 import type { FrontendComponentCategory } from '@wildo-ai/presets-components-models';
-import type { LoadingPolicy } from './loading-types.frontend.schemas.js';
+import type { LoadingPolicy } from './loading-types.frontend.schemas';
 /**
  * Resolves a `LoadingPolicy` via 2-layer resolution:
  *   1. Category defaults (from `CATEGORY_LOADING_DEFAULTS`)

package/dist/esm/core/loading/resolveLoadingPolicy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveLoadingPolicy.d.ts","sourceRoot":"","sources":["../../../../src/core/loading/resolveLoadingPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAItE;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,iBAAiB,EAAE,yBAAyB,EAC5C,QAAQ,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAChC,aAAa,CASf"}
+{"version":3,"file":"resolveLoadingPolicy.d.ts","sourceRoot":"","sources":["../../../../../src/core/loading/resolveLoadingPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAItE;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,iBAAiB,EAAE,yBAAyB,EAC5C,QAAQ,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAChC,aAAa,CASf"}

package/dist/esm/core/loading/resolveLoadingPolicy.js

@@ -22,4 +22,4 @@ export function resolveLoadingPolicy(componentCategory, override) {
         skeletonSchema: override?.skeletonSchema ?? categoryDefault.skeletonSchema,
     };
 }
-//# sourceMappingURL=resolveLoadingPolicy.js.map
+//# sourceMappingURL=resolveLoadingPolicy.js.map

package/dist/esm/core/loading/resolveLoadingPolicy.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolveLoadingPolicy.js","sourceRoot":"","sources":["../../../../src/core/loading/resolveLoadingPolicy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAE9E;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,oBAAoB,CAClC,iBAA4C,EAC5C,QAAiC;IAEjC,MAAM,eAAe,GAAG,yBAAyB,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC;IAC3E,OAAO;QACL,WAAW,EAAE,QAAQ,EAAE,WAAW,IAAI,eAAe,CAAC,WAAW,IAAI,gBAAgB,CAAC,QAAQ;QAC9F,OAAO,EAAE,QAAQ,EAAE,OAAO,IAAI,eAAe,CAAC,OAAO,IAAI,gBAAgB,CAAC,eAAe;QACzF,cAAc,EAAE,QAAQ,EAAE,cAAc,IAAI,eAAe,CAAC,cAAc;QAC1E,kBAAkB,EAAE,QAAQ,EAAE,kBAAkB,IAAI,eAAe,CAAC,kBAAkB;QACtF,cAAc,EAAE,QAAQ,EAAE,cAAc,IAAI,eAAe,CAAC,cAAc;KAC3E,CAAC;AACJ,CAAC"}
+{"version":3,"file":"resolveLoadingPolicy.js","sourceRoot":"","sources":["../../../../../src/core/loading/resolveLoadingPolicy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAE9E;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,oBAAoB,CAClC,iBAA4C,EAC5C,QAAiC;IAEjC,MAAM,eAAe,GAAG,yBAAyB,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC;IAC3E,OAAO;QACL,WAAW,EAAE,QAAQ,EAAE,WAAW,IAAI,eAAe,CAAC,WAAW,IAAI,gBAAgB,CAAC,QAAQ;QAC9F,OAAO,EAAE,QAAQ,EAAE,OAAO,IAAI,eAAe,CAAC,OAAO,IAAI,gBAAgB,CAAC,eAAe;QACzF,cAAc,EAAE,QAAQ,EAAE,cAAc,IAAI,eAAe,CAAC,cAAc;QAC1E,kBAAkB,EAAE,QAAQ,EAAE,kBAAkB,IAAI,eAAe,CAAC,kBAAkB;QACtF,cAAc,EAAE,QAAQ,EAAE,cAAc,IAAI,eAAe,CAAC,cAAc;KAC3E,CAAC;AACJ,CAAC","sourcesContent":["import type { FrontendComponentCategory } from '@wildo-ai/presets-components-models';\nimport type { LoadingPolicy } from './loading-types.frontend.schemas';\nimport { LoadingTreatment } from './loading-types.frontend.schemas';\nimport { CATEGORY_LOADING_DEFAULTS } from './loading-policy.frontend.schemas';\n\n/**\n * Resolves a `LoadingPolicy` via 2-layer resolution:\n *   1. Category defaults (from `CATEGORY_LOADING_DEFAULTS`)\n *   2. Explicit override (preset code or instance props)\n *\n * Categories without defaults (LOW_LEVEL, APP_LAYOUTS, GUIDANCE, PROGRESSION,\n * LIFECYCLE) fall through to framework defaults (SKELETON + OPACITY_OVERLAY).\n * Presets in those categories should always provide explicit overrides.\n *\n * @param componentCategory - The category to look up defaults for\n * @param override - Explicit overrides from the preset or instance\n */\nexport function resolveLoadingPolicy(\n  componentCategory: FrontendComponentCategory,\n  override?: Partial<LoadingPolicy>\n): LoadingPolicy {\n  const categoryDefault = CATEGORY_LOADING_DEFAULTS[componentCategory] ?? {};\n  return {\n    initialLoad: override?.initialLoad ?? categoryDefault.initialLoad ?? LoadingTreatment.SKELETON,\n    refresh: override?.refresh ?? categoryDefault.refresh ?? LoadingTreatment.OPACITY_OVERLAY,\n    customRenderer: override?.customRenderer ?? categoryDefault.customRenderer,\n    disableInteraction: override?.disableInteraction ?? categoryDefault.disableInteraction,\n    skeletonSchema: override?.skeletonSchema ?? categoryDefault.skeletonSchema,\n  };\n}\n"]}

package/dist/esm/core/loading/useAppLoading.d.ts

@@ -3,7 +3,7 @@
  *
  * Separated from LoadingContext.tsx for React Fast Refresh compatibility.
  */
-import type { LoadingSource } from './loading-types.frontend.schemas.js';
+import type { LoadingSource } from './loading-types.frontend.schemas';
 /**
  * Tier 1: Application-level loading state.
  * Returns true when any app-level loading is active (init steps, language change).

package/dist/esm/core/loading/useAppLoading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAppLoading.d.ts","sourceRoot":"","sources":["../../../../src/core/loading/useAppLoading.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAEtE;;;;;;;;GAQG;AACH,wBAAgB,aAAa,IAAI;IAAE,YAAY,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,aAAa,EAAE,CAAA;CAAE,CAInF"}
+{"version":3,"file":"useAppLoading.d.ts","sourceRoot":"","sources":["../../../../../src/core/loading/useAppLoading.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAEtE;;;;;;;;GAQG;AACH,wBAAgB,aAAa,IAAI;IAAE,YAAY,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,aAAa,EAAE,CAAA;CAAE,CAInF"}

package/dist/esm/core/loading/useAppLoading.js

@@ -20,4 +20,4 @@ export function useAppLoading() {
         throw new Error('useAppLoading must be used within a LoadingProvider');
     return { isAppLoading: context.isAppLoading, sources: context.appLoadingSources };
 }
-//# sourceMappingURL=useAppLoading.js.map
+//# sourceMappingURL=useAppLoading.js.map

package/dist/esm/core/loading/useAppLoading.js.map

@@ -1 +1 @@
-{"version":3,"file":"useAppLoading.js","sourceRoot":"","sources":["../../../../src/core/loading/useAppLoading.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACnC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa;IAC3B,MAAM,OAAO,GAAG,UAAU,CAAC,cAAc,CAAC,CAAC;IAC3C,IAAI,CAAC,OAAO;QAAE,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;IACrF,OAAO,EAAE,YAAY,EAAE,OAAO,CAAC,YAAY,EAAE,OAAO,EAAE,OAAO,CAAC,iBAAiB,EAAE,CAAC;AACpF,CAAC"}
+{"version":3,"file":"useAppLoading.js","sourceRoot":"","sources":["../../../../../src/core/loading/useAppLoading.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACnC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa;IAC3B,MAAM,OAAO,GAAG,UAAU,CAAC,cAAc,CAAC,CAAC;IAC3C,IAAI,CAAC,OAAO;QAAE,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;IACrF,OAAO,EAAE,YAAY,EAAE,OAAO,CAAC,YAAY,EAAE,OAAO,EAAE,OAAO,CAAC,iBAAiB,EAAE,CAAC;AACpF,CAAC","sourcesContent":["/**\n * useAppLoading Hook — Tier 1: Application-Level Loading State\n *\n * Separated from LoadingContext.tsx for React Fast Refresh compatibility.\n */\n\nimport { useContext } from 'react';\nimport { LoadingContext } from './LoadingContext';\nimport type { LoadingSource } from './loading-types.frontend.schemas';\n\n/**\n * Tier 1: Application-level loading state.\n * Returns true when any app-level loading is active (init steps, language change).\n *\n * Use this to gate the entire application UI — show a full-screen loading\n * overlay when the app is initializing or switching languages/orgs.\n *\n * @throws Error if used outside of LoadingProvider\n */\nexport function useAppLoading(): { isAppLoading: boolean; sources: LoadingSource[] } {\n  const context = useContext(LoadingContext);\n  if (!context) throw new Error('useAppLoading must be used within a LoadingProvider');\n  return { isAppLoading: context.isAppLoading, sources: context.appLoadingSources };\n}\n"]}

package/dist/esm/core/loading/useComponentLoading.d.ts

@@ -3,7 +3,7 @@
  *
  * Separated from LoadingContext.tsx for React Fast Refresh compatibility.
  */
-import type { LoadingScope } from './loading-types.frontend.schemas.js';
+import type { LoadingScope } from './loading-types.frontend.schemas';
 /**
  * Tier 2: Component-level loading state for a specific scope.
  * Derives isInitialLoad vs isRefreshing from the LoadedOnceCache.

package/dist/esm/core/loading/useComponentLoading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useComponentLoading.d.ts","sourceRoot":"","sources":["../../../../src/core/loading/useComponentLoading.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAGrE;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE;IAAE,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAAE,GACxC;IACD,aAAa,EAAE,OAAO,CAAC;IACvB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,MAAM,IAAI,CAAC;CAC1B,CAqBA"}
+{"version":3,"file":"useComponentLoading.d.ts","sourceRoot":"","sources":["../../../../../src/core/loading/useComponentLoading.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAGrE;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE;IAAE,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAAE,GACxC;IACD,aAAa,EAAE,OAAO,CAAC;IACvB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,MAAM,IAAI,CAAC;CAC1B,CAqBA"}

package/dist/esm/core/loading/useComponentLoading.js

@@ -38,4 +38,4 @@ export function useComponentLoading(scope, options) {
         markRendered,
     };
 }
-//# sourceMappingURL=useComponentLoading.js.map
+//# sourceMappingURL=useComponentLoading.js.map

package/dist/esm/core/loading/useComponentLoading.js.map

@@ -1 +1 @@
-{"version":3,"file":"useComponentLoading.js","sourceRoot":"","sources":["../../../../src/core/loading/useComponentLoading.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAEtE;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAmB,EACnB,OAAyC;IAOzC,MAAM,OAAO,GAAG,UAAU,CAAC,cAAc,CAAC,CAAC;IAC3C,IAAI,CAAC,OAAO;QAAE,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;IAE3F,MAAM,QAAQ,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC;IAC7C,MAAM,KAAK,GAAG,OAAO,CAAC,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IAEzD,MAAM,SAAS,GAAG,KAAK,EAAE,SAAS,IAAI,KAAK,CAAC;IAC5C,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,kBAAkB,CAAC,CAAC;IAEnF,MAAM,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC;IACjD,MAAM,YAAY,GAAG,WAAW,CAAC,GAAG,EAAE;QACpC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IAChC,CAAC,EAAE,CAAC,mBAAmB,EAAE,QAAQ,CAAC,CAAC,CAAC;IAEpC,OAAO;QACL,aAAa,EAAE,SAAS,IAAI,CAAC,aAAa;QAC1C,YAAY,EAAE,SAAS,IAAI,aAAa;QACxC,SAAS;QACT,YAAY;KACb,CAAC;AACJ,CAAC"}
+{"version":3,"file":"useComponentLoading.js","sourceRoot":"","sources":["../../../../../src/core/loading/useComponentLoading.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAEtE;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAmB,EACnB,OAAyC;IAOzC,MAAM,OAAO,GAAG,UAAU,CAAC,cAAc,CAAC,CAAC;IAC3C,IAAI,CAAC,OAAO;QAAE,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;IAE3F,MAAM,QAAQ,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC;IAC7C,MAAM,KAAK,GAAG,OAAO,CAAC,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IAEzD,MAAM,SAAS,GAAG,KAAK,EAAE,SAAS,IAAI,KAAK,CAAC;IAC5C,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,kBAAkB,CAAC,CAAC;IAEnF,MAAM,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC;IACjD,MAAM,YAAY,GAAG,WAAW,CAAC,GAAG,EAAE;QACpC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IAChC,CAAC,EAAE,CAAC,mBAAmB,EAAE,QAAQ,CAAC,CAAC,CAAC;IAEpC,OAAO;QACL,aAAa,EAAE,SAAS,IAAI,CAAC,aAAa;QAC1C,YAAY,EAAE,SAAS,IAAI,aAAa;QACxC,SAAS;QACT,YAAY;KACb,CAAC;AACJ,CAAC","sourcesContent":["/**\n * useComponentLoading Hook — Tier 2: Component-Level Loading State\n *\n * Separated from LoadingContext.tsx for React Fast Refresh compatibility.\n */\n\nimport { useContext, useCallback } from 'react';\nimport { LoadingContext } from './LoadingContext';\nimport type { LoadingScope } from './loading-types.frontend.schemas';\nimport { buildLoadingScopeKey } from './loading-scope.frontend.utils';\n\n/**\n * Tier 2: Component-level loading state for a specific scope.\n * Derives isInitialLoad vs isRefreshing from the LoadedOnceCache.\n *\n * - `isInitialLoad`: Loading AND this scope has never been loaded before → show skeleton\n * - `isRefreshing`: Loading AND this scope was loaded before → show opacity overlay\n * - `isLoading`: Either of the above\n * - `markRendered`: Call after first successful render to record in LoadedOnceCache\n *\n * @param scope - What is being loaded (resource+operation or custom identifier)\n * @param options.refreshThresholdMs - TTL for hasLoadedOnce (default 5 min)\n * @throws Error if used outside of LoadingProvider\n */\nexport function useComponentLoading(\n  scope: LoadingScope,\n  options?: { refreshThresholdMs?: number }\n): {\n  isInitialLoad: boolean;\n  isRefreshing: boolean;\n  isLoading: boolean;\n  markRendered: () => void;\n} {\n  const context = useContext(LoadingContext);\n  if (!context) throw new Error('useComponentLoading must be used within a LoadingProvider');\n\n  const scopeKey = buildLoadingScopeKey(scope);\n  const state = context.getComponentLoadingState(scopeKey);\n\n  const isLoading = state?.isLoading ?? false;\n  const hasLoadedOnce = context.hasLoadedOnce(scopeKey, options?.refreshThresholdMs);\n\n  const contextMarkRendered = context.markRendered;\n  const markRendered = useCallback(() => {\n    contextMarkRendered(scopeKey);\n  }, [contextMarkRendered, scopeKey]);\n\n  return {\n    isInitialLoad: isLoading && !hasLoadedOnce,\n    isRefreshing: isLoading && hasLoadedOnce,\n    isLoading,\n    markRendered,\n  };\n}\n"]}

package/dist/esm/core/loading/useEmitLoadingScope.d.ts

@@ -0,0 +1,57 @@
+/**
+ * useEmitLoadingScope — Tier-2 context loading emitter (L-2.b)
+ *
+ * Ergonomic wrapper around `LoadingContext.fireLoading`/`endLoading` for the
+ * "context publishes its lifecycle" use-case. Handles three things consumers
+ * would otherwise reinvent:
+ *
+ * 1. **Tier defaulting** — always emits as `LoadingTier.COMPONENT` (Tier-1
+ *    `APPLICATION` is reserved for app-init / language-change events).
+ * 2. **Phase derivation** — accepts a single `isLoading` boolean and figures
+ *    out whether to emit START or END (and with which phase).
+ * 3. **Cleanup** — guarantees an `endLoading` is fired on unmount, so an
+ *    in-flight scope can never leak past the provider's lifetime.
+ *
+ * The hook does **not** own the loading state — the calling context still
+ * tracks `isLoading` locally for its own consumers and back-compat. It just
+ * mirrors that state to the LoadingContext event bus so unrelated components
+ * can observe it via `useComponentLoading({ customIdentifier })` or wrap
+ * content in `<LoadingGate scopes={[...]}>`.
+ */
+import { ContextLoadingIdentifier } from './loading-types.frontend.schemas';
+/**
+ * Mirror a context's local `isLoading` boolean onto the LoadingContext event
+ * bus under a typed `ContextLoadingIdentifier`.
+ *
+ * Usage:
+ *
+ * ```tsx
+ * // Inside BillingContext
+ * useEmitLoadingScope({
+ *   identifier: ContextLoadingIdentifier.BILLING_STATE,
+ *   isLoading,
+ *   hasLoadedOnce: billingState !== null,
+ * });
+ * ```
+ *
+ * Downstream observers:
+ *
+ * ```tsx
+ * const { isInitialLoad } = useComponentLoading({
+ *   customIdentifier: ContextLoadingIdentifier.BILLING_STATE,
+ * });
+ * ```
+ *
+ * @param params.identifier — typed scope identifier
+ * @param params.isLoading — current loading boolean from the context
+ * @param params.hasLoadedOnce — distinguishes INITIAL vs REFRESH phase. Pass
+ *   `true` once the first successful payload has arrived. Optional; defaults
+ *   to `false` (always treats as INITIAL) which is acceptable for contexts
+ *   whose first load is the only "skeleton-worthy" wait.
+ */
+export declare function useEmitLoadingScope(params: {
+    identifier: ContextLoadingIdentifier;
+    isLoading: boolean;
+    hasLoadedOnce?: boolean;
+}): void;
+//# sourceMappingURL=useEmitLoadingScope.d.ts.map

package/dist/esm/core/loading/useEmitLoadingScope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEmitLoadingScope.d.ts","sourceRoot":"","sources":["../../../../../src/core/loading/useEmitLoadingScope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAKH,OAAO,EACL,wBAAwB,EAGzB,MAAM,kCAAkC,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,UAAU,EAAE,wBAAwB,CAAC;IACrC,SAAS,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,GAAG,IAAI,CAyCP"}

package/dist/esm/core/loading/useEmitLoadingScope.js

@@ -0,0 +1,94 @@
+/**
+ * useEmitLoadingScope — Tier-2 context loading emitter (L-2.b)
+ *
+ * Ergonomic wrapper around `LoadingContext.fireLoading`/`endLoading` for the
+ * "context publishes its lifecycle" use-case. Handles three things consumers
+ * would otherwise reinvent:
+ *
+ * 1. **Tier defaulting** — always emits as `LoadingTier.COMPONENT` (Tier-1
+ *    `APPLICATION` is reserved for app-init / language-change events).
+ * 2. **Phase derivation** — accepts a single `isLoading` boolean and figures
+ *    out whether to emit START or END (and with which phase).
+ * 3. **Cleanup** — guarantees an `endLoading` is fired on unmount, so an
+ *    in-flight scope can never leak past the provider's lifetime.
+ *
+ * The hook does **not** own the loading state — the calling context still
+ * tracks `isLoading` locally for its own consumers and back-compat. It just
+ * mirrors that state to the LoadingContext event bus so unrelated components
+ * can observe it via `useComponentLoading({ customIdentifier })` or wrap
+ * content in `<LoadingGate scopes={[...]}>`.
+ */
+import { useContext, useEffect, useRef } from 'react';
+import { LoadingContext } from './LoadingContext.js';
+import { buildContextLoadingScope } from './loading-scope.frontend.utils.js';
+import { LoadingPhase, LoadingTier, } from './loading-types.frontend.schemas.js';
+/**
+ * Mirror a context's local `isLoading` boolean onto the LoadingContext event
+ * bus under a typed `ContextLoadingIdentifier`.
+ *
+ * Usage:
+ *
+ * ```tsx
+ * // Inside BillingContext
+ * useEmitLoadingScope({
+ *   identifier: ContextLoadingIdentifier.BILLING_STATE,
+ *   isLoading,
+ *   hasLoadedOnce: billingState !== null,
+ * });
+ * ```
+ *
+ * Downstream observers:
+ *
+ * ```tsx
+ * const { isInitialLoad } = useComponentLoading({
+ *   customIdentifier: ContextLoadingIdentifier.BILLING_STATE,
+ * });
+ * ```
+ *
+ * @param params.identifier — typed scope identifier
+ * @param params.isLoading — current loading boolean from the context
+ * @param params.hasLoadedOnce — distinguishes INITIAL vs REFRESH phase. Pass
+ *   `true` once the first successful payload has arrived. Optional; defaults
+ *   to `false` (always treats as INITIAL) which is acceptable for contexts
+ *   whose first load is the only "skeleton-worthy" wait.
+ */
+export function useEmitLoadingScope(params) {
+    // Resilience: emission is **opt-in observability**, NOT load-bearing.
+    // A context that calls this hook must remain functional when mounted
+    // outside a `LoadingProvider` (the calling context's own `isLoading` is
+    // still the source of truth for direct consumers). This keeps test
+    // harnesses, isolated story rigs, and minimal-shell apps from being
+    // forced to add `LoadingProvider` just because a downstream context
+    // wants to publish lifecycle events.
+    const loadingCtx = useContext(LoadingContext);
+    const fireLoading = loadingCtx?.fireLoading;
+    const endLoading = loadingCtx?.endLoading;
+    const wasLoadingRef = useRef(false);
+    useEffect(() => {
+        if (!fireLoading || !endLoading)
+            return;
+        const scope = buildContextLoadingScope(params.identifier);
+        const tier = LoadingTier.COMPONENT;
+        if (params.isLoading && !wasLoadingRef.current) {
+            fireLoading(scope, {
+                tier,
+                phase: params.hasLoadedOnce ? LoadingPhase.REFRESH : LoadingPhase.INITIAL,
+            });
+            wasLoadingRef.current = true;
+        }
+        else if (!params.isLoading && wasLoadingRef.current) {
+            endLoading(scope, { tier });
+            wasLoadingRef.current = false;
+        }
+    }, [params.identifier, params.isLoading, params.hasLoadedOnce, fireLoading, endLoading]);
+    useEffect(() => {
+        return () => {
+            if (wasLoadingRef.current && endLoading) {
+                const scope = buildContextLoadingScope(params.identifier);
+                endLoading(scope, { tier: LoadingTier.COMPONENT });
+                wasLoadingRef.current = false;
+            }
+        };
+    }, [params.identifier, endLoading]);
+}
+//# sourceMappingURL=useEmitLoadingScope.js.map

package/dist/esm/core/loading/useEmitLoadingScope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEmitLoadingScope.js","sourceRoot":"","sources":["../../../../../src/core/loading/useEmitLoadingScope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,EAEL,YAAY,EACZ,WAAW,GACZ,MAAM,kCAAkC,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAInC;IACC,sEAAsE;IACtE,qEAAqE;IACrE,wEAAwE;IACxE,mEAAmE;IACnE,oEAAoE;IACpE,oEAAoE;IACpE,qCAAqC;IACrC,MAAM,UAAU,GAAG,UAAU,CAAC,cAAc,CAAC,CAAC;IAC9C,MAAM,WAAW,GAAG,UAAU,EAAE,WAAW,CAAC;IAC5C,MAAM,UAAU,GAAG,UAAU,EAAE,UAAU,CAAC;IAE1C,MAAM,aAAa,GAAG,MAAM,CAAU,KAAK,CAAC,CAAC;IAE7C,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,CAAC,WAAW,IAAI,CAAC,UAAU;YAAE,OAAO;QAExC,MAAM,KAAK,GAAG,wBAAwB,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QAC1D,MAAM,IAAI,GAAG,WAAW,CAAC,SAAS,CAAC;QAEnC,IAAI,MAAM,CAAC,SAAS,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;YAC/C,WAAW,CAAC,KAAK,EAAE;gBACjB,IAAI;gBACJ,KAAK,EAAE,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,OAAO;aAC1E,CAAC,CAAC;YACH,aAAa,CAAC,OAAO,GAAG,IAAI,CAAC;QAC/B,CAAC;aAAM,IAAI,CAAC,MAAM,CAAC,SAAS,IAAI,aAAa,CAAC,OAAO,EAAE,CAAC;YACtD,UAAU,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;YAC5B,aAAa,CAAC,OAAO,GAAG,KAAK,CAAC;QAChC,CAAC;IACH,CAAC,EAAE,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,aAAa,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC;IAEzF,SAAS,CAAC,GAAG,EAAE;QACb,OAAO,GAAG,EAAE;YACV,IAAI,aAAa,CAAC,OAAO,IAAI,UAAU,EAAE,CAAC;gBACxC,MAAM,KAAK,GAAG,wBAAwB,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;gBAC1D,UAAU,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,WAAW,CAAC,SAAS,EAAE,CAAC,CAAC;gBACnD,aAAa,CAAC,OAAO,GAAG,KAAK,CAAC;YAChC,CAAC;QACH,CAAC,CAAC;IACJ,CAAC,EAAE,CAAC,MAAM,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;AACtC,CAAC","sourcesContent":["/**\n * useEmitLoadingScope — Tier-2 context loading emitter (L-2.b)\n *\n * Ergonomic wrapper around `LoadingContext.fireLoading`/`endLoading` for the\n * \"context publishes its lifecycle\" use-case. Handles three things consumers\n * would otherwise reinvent:\n *\n * 1. **Tier defaulting** — always emits as `LoadingTier.COMPONENT` (Tier-1\n *    `APPLICATION` is reserved for app-init / language-change events).\n * 2. **Phase derivation** — accepts a single `isLoading` boolean and figures\n *    out whether to emit START or END (and with which phase).\n * 3. **Cleanup** — guarantees an `endLoading` is fired on unmount, so an\n *    in-flight scope can never leak past the provider's lifetime.\n *\n * The hook does **not** own the loading state — the calling context still\n * tracks `isLoading` locally for its own consumers and back-compat. It just\n * mirrors that state to the LoadingContext event bus so unrelated components\n * can observe it via `useComponentLoading({ customIdentifier })` or wrap\n * content in `<LoadingGate scopes={[...]}>`.\n */\n\nimport { useContext, useEffect, useRef } from 'react';\nimport { LoadingContext } from './LoadingContext';\nimport { buildContextLoadingScope } from './loading-scope.frontend.utils';\nimport {\n  ContextLoadingIdentifier,\n  LoadingPhase,\n  LoadingTier,\n} from './loading-types.frontend.schemas';\n\n/**\n * Mirror a context's local `isLoading` boolean onto the LoadingContext event\n * bus under a typed `ContextLoadingIdentifier`.\n *\n * Usage:\n *\n * ```tsx\n * // Inside BillingContext\n * useEmitLoadingScope({\n *   identifier: ContextLoadingIdentifier.BILLING_STATE,\n *   isLoading,\n *   hasLoadedOnce: billingState !== null,\n * });\n * ```\n *\n * Downstream observers:\n *\n * ```tsx\n * const { isInitialLoad } = useComponentLoading({\n *   customIdentifier: ContextLoadingIdentifier.BILLING_STATE,\n * });\n * ```\n *\n * @param params.identifier — typed scope identifier\n * @param params.isLoading — current loading boolean from the context\n * @param params.hasLoadedOnce — distinguishes INITIAL vs REFRESH phase. Pass\n *   `true` once the first successful payload has arrived. Optional; defaults\n *   to `false` (always treats as INITIAL) which is acceptable for contexts\n *   whose first load is the only \"skeleton-worthy\" wait.\n */\nexport function useEmitLoadingScope(params: {\n  identifier: ContextLoadingIdentifier;\n  isLoading: boolean;\n  hasLoadedOnce?: boolean;\n}): void {\n  // Resilience: emission is **opt-in observability**, NOT load-bearing.\n  // A context that calls this hook must remain functional when mounted\n  // outside a `LoadingProvider` (the calling context's own `isLoading` is\n  // still the source of truth for direct consumers). This keeps test\n  // harnesses, isolated story rigs, and minimal-shell apps from being\n  // forced to add `LoadingProvider` just because a downstream context\n  // wants to publish lifecycle events.\n  const loadingCtx = useContext(LoadingContext);\n  const fireLoading = loadingCtx?.fireLoading;\n  const endLoading = loadingCtx?.endLoading;\n\n  const wasLoadingRef = useRef<boolean>(false);\n\n  useEffect(() => {\n    if (!fireLoading || !endLoading) return;\n\n    const scope = buildContextLoadingScope(params.identifier);\n    const tier = LoadingTier.COMPONENT;\n\n    if (params.isLoading && !wasLoadingRef.current) {\n      fireLoading(scope, {\n        tier,\n        phase: params.hasLoadedOnce ? LoadingPhase.REFRESH : LoadingPhase.INITIAL,\n      });\n      wasLoadingRef.current = true;\n    } else if (!params.isLoading && wasLoadingRef.current) {\n      endLoading(scope, { tier });\n      wasLoadingRef.current = false;\n    }\n  }, [params.identifier, params.isLoading, params.hasLoadedOnce, fireLoading, endLoading]);\n\n  useEffect(() => {\n    return () => {\n      if (wasLoadingRef.current && endLoading) {\n        const scope = buildContextLoadingScope(params.identifier);\n        endLoading(scope, { tier: LoadingTier.COMPONENT });\n        wasLoadingRef.current = false;\n      }\n    };\n  }, [params.identifier, endLoading]);\n}\n"]}

package/dist/esm/core/loading/useLoading.d.ts

@@ -1,4 +1,4 @@
-import { type LoadingContextType } from './LoadingContext.js';
+import { type LoadingContextType } from './LoadingContext';
 /**
  * useLoading Hook
  *

package/dist/esm/core/loading/useLoading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLoading.d.ts","sourceRoot":"","sources":["../../../../src/core/loading/useLoading.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3E;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,QAAO,kBAM7B,CAAC"}
+{"version":3,"file":"useLoading.d.ts","sourceRoot":"","sources":["../../../../../src/core/loading/useLoading.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3E;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,QAAO,kBAM7B,CAAC"}

package/dist/esm/core/loading/useLoading.js

@@ -17,4 +17,4 @@ export const useLoading = () => {
     }
     return context;
 };
-//# sourceMappingURL=useLoading.js.map
+//# sourceMappingURL=useLoading.js.map

package/dist/esm/core/loading/useLoading.js.map

@@ -1 +1 @@
-{"version":3,"file":"useLoading.js","sourceRoot":"","sources":["../../../../src/core/loading/useLoading.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACnC,OAAO,EAAE,cAAc,EAA2B,MAAM,kBAAkB,CAAC;AAE3E;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,GAAuB,EAAE;IACjD,MAAM,OAAO,GAAG,UAAU,CAAC,cAAc,CAAC,CAAC;IAC3C,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC"}
+{"version":3,"file":"useLoading.js","sourceRoot":"","sources":["../../../../../src/core/loading/useLoading.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACnC,OAAO,EAAE,cAAc,EAA2B,MAAM,kBAAkB,CAAC;AAE3E;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,GAAuB,EAAE;IACjD,MAAM,OAAO,GAAG,UAAU,CAAC,cAAc,CAAC,CAAC;IAC3C,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC","sourcesContent":["import { useContext } from 'react';\nimport { LoadingContext, type LoadingContextType } from './LoadingContext';\n\n/**\n * useLoading Hook\n *\n * Separated from LoadingContext.tsx for React Fast Refresh compatibility.\n * Prefer useAppLoading() for Tier 1 or useComponentLoading() for Tier 2 when\n * only those concerns are needed.\n *\n * @returns LoadingContextType with fireLoading, endLoading, and state access\n * @throws Error if used outside of LoadingProvider\n */\nexport const useLoading = (): LoadingContextType => {\n  const context = useContext(LoadingContext);\n  if (!context) {\n    throw new Error('useLoading must be used within a LoadingProvider');\n  }\n  return context;\n};\n\n"]}

package/dist/esm/core/mode/AppModeContext.d.ts

@@ -19,7 +19,7 @@
  */
 import React from 'react';
 import type { ReactNode } from 'react';
-import type { AppModeDefinition } from '../../core/config/launcher-items.frontend.schemas.js';
+import type { AppModeDefinition } from '../../core/config/launcher-items.frontend.schemas';
 export interface AppModeContextValue {
     /** All declared app modes (before user type filtering). */
     allModes: AppModeDefinition[];

package/dist/esm/core/mode/AppModeContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AppModeContext.d.ts","sourceRoot":"","sources":["../../../../src/core/mode/AppModeContext.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAA+E,MAAM,OAAO,CAAC;AACpG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iEAAiE,CAAC;AAQzG,MAAM,WAAW,mBAAmB;IAClC,2DAA2D;IAC3D,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAC9B,kFAAkF;IAClF,cAAc,EAAE,iBAAiB,EAAE,CAAC;IACpC,8DAA8D;IAC9D,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,2EAA2E;IAC3E,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,sDAAsD;IACtD,QAAQ,EAAE,OAAO,CAAC;CACnB;AAkED,UAAU,oBAAoB;IAC5B,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA6D1D,CAAC;AAMF;;GAEG;AACH,wBAAgB,UAAU,IAAI,mBAAmB,CAMhD;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,mBAAmB,GAAG,IAAI,CAE3D"}
+{"version":3,"file":"AppModeContext.d.ts","sourceRoot":"","sources":["../../../../../src/core/mode/AppModeContext.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAA+E,MAAM,OAAO,CAAC;AACpG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iEAAiE,CAAC;AAQzG,MAAM,WAAW,mBAAmB;IAClC,2DAA2D;IAC3D,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAC9B,kFAAkF;IAClF,cAAc,EAAE,iBAAiB,EAAE,CAAC;IACpC,8DAA8D;IAC9D,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,2EAA2E;IAC3E,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,sDAAsD;IACtD,QAAQ,EAAE,OAAO,CAAC;CACnB;AAkED,UAAU,oBAAoB;IAC5B,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA6D1D,CAAC;AAMF;;GAEG;AACH,wBAAgB,UAAU,IAAI,mBAAmB,CAMhD;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,mBAAmB,GAAG,IAAI,CAE3D"}

package/dist/esm/core/mode/AppModeContext.js

@@ -132,4 +132,4 @@ export function useAppMode() {
 export function useAppModeSafe() {
     return useContext(AppModeContext) ?? null;
 }
-//# sourceMappingURL=AppModeContext.js.map
+//# sourceMappingURL=AppModeContext.js.map