@wildo-ai/saas-frontend-lib 1.1.5 → 1.1.6

package/dist/esm/core/components-registry/provider-component-registry.frontend.service.js

@@ -1,259 +1,38 @@
 /**
- * Components contributed by PROVIDERS, keyed by the capability each fills.
- *
- * ## Why this is a sibling of `ComponentRegistryService` and not an extension
- *
- * The two answer different questions, and the difference is in the KEY, the
- * cardinality and the lifecycle — not in whether a vocabulary is open:
- *
- *   - `ComponentRegistryService` keys `componentType:preset[:category]`, where
- *     `FrontendComponentType` is a CLOSED enum the engine owns. Exactly one
- *     component answers a key, resolution is synchronous, and a missing
- *     registration is a startup refusal.
- *   - This registry keys `capability:providerRef`. The capability half is
- *     closed too (`ProviderCapability` is the built-in set since #502 removed
- *     module augmentation), but the PROVIDER half is not engine-owned at all:
- *     refs arrive from engine modules, generated packages and application
- *     packages, discovered per deployment. SEVERAL providers may answer one
- *     capability, the component arrives asynchronously, and none of it is
- *     required for the app to mount.
- *
- * Forcing provider components through `FrontendComponentType` would mean an
- * engine enum member per capability and a preset per provider, and would make "which component
- * answers this key" ambiguous in a registry whose whole contract is that it is
- * not. (This paragraph used to justify the split by calling `ProviderCapability`
- * OPEN; that stopped being true with #502, and the split stands on the reasons
- * above.)
- *
- * It also keeps the blast radius honest. `ComponentRegistryService` has sixteen
- * consumers across four packages (re-measured 2026-09-06; the plan's figure of
- * eleven predates several of them), most of them outside this slice's territory.
- * A sibling registry touches none of them.
- *
- * ## Several providers, and no silent winner
- *
- * `listProviders` returns every provider offering a component for a capability,
- * in registration order, and nothing here picks one. That is deliberate: the
- * defect being fixed is that resolution WAS first-match, so a Drive picker and
- * a Dropbox picker could not coexist and the winner depended on map order. A
- * surface with two providers has a choice to present; a registry that answered
- * it would be making a product decision in a lookup table.
- */
-import { collectDeclaredProviderScripts, loadProviderScripts, } from '@wildo-ai/external-connectors-public/app';
-import { describeCaughtError } from '@wildo-ai/saas-models';
-/** Why a provider component could not be registered or loaded. */
-export var ProviderComponentDiagnosticKind;
-(function (ProviderComponentDiagnosticKind) {
-    /**
-     * A second registration arrived for one capability AND provider. The first is
-     * kept: a duplicate is a wiring mistake, and swapping the live component
-     * under a mounted surface would be worse than ignoring it.
-     */
-    ProviderComponentDiagnosticKind["DUPLICATE_REGISTRATION"] = "DUPLICATE_REGISTRATION";
-    /** The loader threw or rejected. That provider's component is unavailable; others are not affected. */
-    ProviderComponentDiagnosticKind["LOAD_FAILED"] = "LOAD_FAILED";
-    /**
-     * The loader resolved something that is not a component. Almost always a
-     * loader returning a MODULE NAMESPACE — `() => import('./Picker.js')` — where it
-     * should return the component itself.
-     */
-    ProviderComponentDiagnosticKind["LOADED_VALUE_IS_NOT_A_COMPONENT"] = "LOADED_VALUE_IS_NOT_A_COMPONENT";
-    /**
-     * A live provider DECLARES a component for a capability and nothing supplies
-     * its loader — neither the module (`components[cap].load`) nor the facet
-     * library (`contributeProviderComponentLoaders`). The declaration is DATA a
-     * reviewer can read; without code behind it the chooser would offer a picker
-     * that cannot open. Not registered, and reported once at startup.
-     */
-    ProviderComponentDiagnosticKind["DECLARED_WITHOUT_LOADER"] = "DECLARED_WITHOUT_LOADER";
-    /**
-     * BOTH the module and the facet library supplied a loader for one
-     * `capability:providerRef`. The module's wins — it is the provider's own
-     * word — and the collision is reported, because the engine never authors both
-     * and two loaders for one declaration is the map-order ambiguity #380 removed.
-     */
-    ProviderComponentDiagnosticKind["LOADER_SUPPLIED_TWICE"] = "LOADER_SUPPLIED_TWICE";
-    /**
-     * A `<script>` the declaring provider needs did not load — a network failure,
-     * a Content-Security-Policy refusal, or an integrity mismatch. The component
-     * resolves `null`, and that answer is CACHED exactly like `LOAD_FAILED`: the
-     * failed element stays in the document and is not retried this session (a
-     * vendor script can fail after partially executing, and a second copy could
-     * initialise over the first), so a chooser re-rendering must not re-ask. A
-     * component whose vendor global is absent is not usable, and handing it back
-     * would only move the failure into its own mount ("The Google API script has
-     * not loaded"), where nothing can name the provider's declaration as the cause.
-     */
-    ProviderComponentDiagnosticKind["SCRIPT_LOAD_FAILED"] = "SCRIPT_LOAD_FAILED";
-})(ProviderComponentDiagnosticKind || (ProviderComponentDiagnosticKind = {}));
-/**
- * The default script loader: the shared `loadProviderScripts` against the live
- * `document`, read at CALL time rather than at registry construction. No
- * `typeof document` guard: this package is pure-frontend (engine rule), and a
- * host with no DOM injects its own `loadScripts`.
+ * The APPLICATION's half of the provider-component registry.
+ *
+ * The registry itself — keyed `capability:providerRef`, consent-gated, script-before-component,
+ * browser-only — lives in `@wildo-ai/external-connectors-public` since #1703, because the website
+ * and the documentation site have to build the same registry from the same `components`
+ * declaration and neither may import this package. Read its module header
+ * (`createProviderComponentRegistry`) for why it is a sibling of `ComponentRegistryService` and why
+ * it never picks a provider.
+ *
+ * What stays here is what only the application has:
+ *
+ *   - the component TYPE the application renders (`ProviderComponent`), which fills the shared
+ *     registry's type parameter;
+ *   - the application's facet-library door, `contributeProviderComponentLoaders`, through which
+ *     `presets-components` supplies loaders for engine-shipped components (#394). It is module-level
+ *     state on purpose: `registerDefaultPresets` runs before `startApplication` builds the registry,
+ *     the same ordering `ComponentRegistryService.register` relies on. The website and the
+ *     documentation site take the same contributions as an explicit input instead, because their
+ *     wiring has a single construction site that can carry it.
  */
-const loadProviderScriptsIntoDocument = (scripts) => loadProviderScripts(scripts, document);
-function isModuleNamespace(value) {
-    return (typeof value === 'object'
-        && value !== null
-        && value[Symbol.toStringTag] === 'Module');
-}
+import { indexProviderComponentLoaderContributions } from '@wildo-ai/external-connectors-public/app';
+let contributedLoaders = new Map();
 /**
- * A React component is a function, or an object for `memo` / `forwardRef` /
- * `lazy`. Anything else — a namespace, a string, a plain data object — cannot
- * be rendered, and finding out at render time means a blank surface with a
- * stack trace pointing at React rather than at the provider.
- */
-function looksLikeComponent(value) {
-    return typeof value === 'function' || (typeof value === 'object' && value !== null);
-}
-export function createProviderComponentRegistry(input) {
-    const raise = (diagnostic) => {
-        input?.onDiagnostic?.(diagnostic);
-    };
-    const loaders = new Map();
-    const scriptsByKey = new Map();
-    const loadScripts = input?.loadScripts ?? loadProviderScriptsIntoDocument;
-    const descriptors = new Map();
-    const byCapability = new Map();
-    const loaded = new Map();
-    const keyOf = (capability, providerRef) => `${capability}:${providerRef}`;
-    for (const registration of input?.registrations ?? []) {
-        const key = keyOf(registration.capability, registration.providerRef);
-        if (loaders.has(key)) {
-            raise({
-                kind: ProviderComponentDiagnosticKind.DUPLICATE_REGISTRATION,
-                capability: registration.capability,
-                providerRef: registration.providerRef,
-                message: `Provider "${registration.providerRef}" registered a component for "${registration.capability}" `
-                    + 'more than once. The first registration is kept.',
-            });
-            continue;
-        }
-        loaders.set(key, registration.load);
-        if (registration.scripts !== undefined && registration.scripts.length > 0) {
-            scriptsByKey.set(key, registration.scripts);
-        }
-        descriptors.set(key, registration.descriptor);
-        const providers = byCapability.get(registration.capability) ?? [];
-        providers.push(registration.providerRef);
-        byCapability.set(registration.capability, providers);
-    }
-    return {
-        listProviders(capability) {
-            return byCapability.get(capability) ?? [];
-        },
-        has(capability, providerRef) {
-            return loaders.has(keyOf(capability, providerRef));
-        },
-        describe(capability, providerRef) {
-            return descriptors.get(keyOf(capability, providerRef));
-        },
-        resolve(capability, providerRef) {
-            const key = keyOf(capability, providerRef);
-            const cached = loaded.get(key);
-            if (cached !== undefined)
-                return cached;
-            const load = loaders.get(key);
-            if (load === undefined)
-                return Promise.resolve(null);
-            const declaredScripts = scriptsByKey.get(key) ?? [];
-            const pending = (async () => {
-                // Both halves start together: the picker chunk and the vendor loader are
-                // independent downloads, and serialising them would make every first
-                // open wait for their SUM instead of the slower of the two.
-                //
-                // Each half is started through `Promise.resolve().then(...)` so a loader
-                // that throws SYNCHRONOUSLY is still a reported failure rather than an
-                // exception escaping `resolve`, and a script loader that breaks its
-                // never-rejects contract is still a SCRIPT_LOAD_FAILED rather than an
-                // unhandled rejection in a render path.
-                const scriptsToLoad = declaredScripts.map((declaration) => ({ providerRef, declaration }));
-                const [componentResult, scriptOutcome] = await Promise.all([
-                    Promise.resolve().then(load).then((value) => ({ ok: true, value }), (cause) => ({ ok: false, cause })),
-                    scriptsToLoad.length === 0
-                        ? Promise.resolve(undefined)
-                        : Promise.resolve().then(() => loadScripts(scriptsToLoad)).catch((cause) => ({
-                            loaded: [],
-                            failed: scriptsToLoad.map(({ declaration }) => ({
-                                providerRef,
-                                src: declaration.src,
-                                message: `The script loader failed before reporting an outcome: ${describeCaughtError(cause)}`,
-                            })),
-                        })),
-                ]);
-                // Reported independently so a first open that fails on BOTH halves names
-                // both causes, rather than making the second one visible only after the
-                // first is fixed.
-                for (const failure of scriptOutcome?.failed ?? []) {
-                    raise({
-                        kind: ProviderComponentDiagnosticKind.SCRIPT_LOAD_FAILED,
-                        capability,
-                        providerRef,
-                        message: `Provider "${providerRef}" cannot offer its "${capability}" component: a script it declares did not load. `
-                            + failure.message,
-                    });
-                }
-                if (componentResult.ok === false) {
-                    raise({
-                        kind: ProviderComponentDiagnosticKind.LOAD_FAILED,
-                        capability,
-                        providerRef,
-                        message: `Provider "${providerRef}" failed to load its "${capability}" component.`,
-                        cause: componentResult.cause,
-                    });
-                    return null;
-                }
-                if ((scriptOutcome?.failed.length ?? 0) > 0)
-                    return null;
-                const value = componentResult.value;
-                if (isModuleNamespace(value)) {
-                    raise({
-                        kind: ProviderComponentDiagnosticKind.LOADED_VALUE_IS_NOT_A_COMPONENT,
-                        capability,
-                        providerRef,
-                        message: `Provider "${providerRef}" returned a MODULE for its "${capability}" component instead of the `
-                            + "component itself. Write `async () => (await import('./Picker.js')).Picker` rather than "
-                            + "`() => import('./Picker.js')`.",
-                    });
-                    return null;
-                }
-                if (!looksLikeComponent(value)) {
-                    raise({
-                        kind: ProviderComponentDiagnosticKind.LOADED_VALUE_IS_NOT_A_COMPONENT,
-                        capability,
-                        providerRef,
-                        message: `Provider "${providerRef}" returned a ${typeof value} for its "${capability}" component. A React `
-                            + 'component is a function, or an object for memo / forwardRef / lazy.',
-                    });
-                    return null;
-                }
-                return value;
-            })();
-            // Cached even when it resolves to null: a loader — or a script — that failed
-            // once must not be retried on every render of a chooser that lists it.
-            loaded.set(key, pending);
-            return pending;
-        },
-    };
-}
-const contributedLoaders = new Map();
-const loaderKeyOf = (capability, providerRef) => `${capability}:${providerRef}`;
-/**
- * Registers loaders for provider components a facet library ships. Module-level
- * and idempotent per key, like `ComponentRegistryService.register`: the app
- * calls the library's registration entry once at startup, and a second
- * contribution for one key replaces the first rather than duplicating it —
+ * Registers loaders for provider components a facet library ships. Module-level and idempotent per
+ * key, like `ComponentRegistryService.register`: the app calls the library's registration entry once
+ * at startup, and a second contribution for one key replaces the first rather than duplicating it —
  * the library is one author, and the last thing it said is what it means.
  *
- * A contribution for a provider the DATA channel does not declare live is
- * SILENT, by the same rule as code without data in `hydrateFrontendProviderModules`:
- * a bundle legitimately ships a picker an environment leaves off.
+ * A contribution for a provider the DATA channel does not declare live is SILENT, by the same rule
+ * as code without data in `hydrateFrontendProviderModules`: a bundle legitimately ships a picker an
+ * environment leaves off.
  */
 export function contributeProviderComponentLoaders(loaders) {
-    for (const loader of loaders) {
-        contributedLoaders.set(loaderKeyOf(loader.capability, loader.providerRef), loader);
-    }
+    contributedLoaders = indexProviderComponentLoaderContributions([...contributedLoaders.values(), ...loaders]);
 }
 /** Every contributed loader, keyed `capability:providerRef`. Read at registry construction. */
 export function listContributedProviderComponentLoaders() {
@@ -261,83 +40,6 @@ export function listContributedProviderComponentLoaders() {
 }
 /** Tests only: forget every contributed loader. */
 export function _clearContributedProviderComponentLoaders() {
-    contributedLoaders.clear();
-}
-/**
- * Turns the live provider modules into registrations, joining each declared
- * component to its loader — from the module when it carries one, else from
- * the facet library's contributions.
- *
- * Order follows the registry's iteration order, which is the order the service
- * declared its providers — so `listProviders` is stable across reloads and a
- * surface that shows a chooser does not reorder itself between renders.
- *
- * A declaration nothing can load is NOT registered: a chooser must offer only
- * what can render. It is reported through `onDiagnostic` instead, once, at
- * startup — which is the moment somebody can still fix it.
- */
-export function collectProviderComponentRegistrations(modules, input) {
-    const registrations = [];
-    const contributed = input?.contributedLoaders ?? listContributedProviderComponentLoaders();
-    for (const module of modules) {
-        for (const [capability, declaration] of Object.entries(module.components ?? {})) {
-            const providerRef = module.metadata.ref;
-            const supplied = contributed.get(loaderKeyOf(capability, providerRef));
-            if (declaration.load !== undefined && supplied !== undefined) {
-                input?.onDiagnostic?.({
-                    kind: ProviderComponentDiagnosticKind.LOADER_SUPPLIED_TWICE,
-                    capability,
-                    providerRef,
-                    message: `Provider "${providerRef}" carries its own loader for "${capability}" AND the facet library contributed `
-                        + "one. The module's is used; remove one of the two.",
-                });
-            }
-            const load = declaration.load ?? supplied?.load;
-            if (load === undefined) {
-                input?.onDiagnostic?.({
-                    kind: ProviderComponentDiagnosticKind.DECLARED_WITHOUT_LOADER,
-                    capability,
-                    providerRef,
-                    message: `Provider "${providerRef}" declares a "${capability}" component and nothing supplies its loader — `
-                        + 'neither the module nor the facet library. It is not offered. An engine-shipped component is '
-                        + 'registered by the facet library (presets-components for the app); a provider package supplies '
-                        + '`components[capability].load`.',
-                });
-                continue;
-            }
-            registrations.push({
-                capability: capability,
-                providerRef,
-                load,
-                // Only the declared half, never the whole declaration: `load` is already
-                // carried beside it, and a registration holding the same function twice
-                // is two places for one fact to go stale.
-                descriptor: { selectionDelivery: declaration.selectionDelivery },
-                // The PROVIDER's scripts, not the component's: a module declares scripts
-                // once, and the component is the first of its code to run on this surface
-                // — so it is what they load with.
-                ...(module.scripts !== undefined && module.scripts.length > 0 ? { scripts: module.scripts } : {}),
-            });
-        }
-    }
-    return registrations;
-}
-/**
- * The scripts a surface must load at STARTUP: those declared by live providers that
- * contribute NO registered component.
- *
- * A provider's scripts load when its code first runs on the surface. A provider with a
- * registered component has that moment — the registry loads its scripts when the
- * component is first resolved, so no page pays for a picker's vendor loader nobody
- * opened. A provider without one never will, so its scripts load at startup, the same
- * population rule SDK activation uses. A provider that DECLARES a component nothing
- * can load is not registered and therefore counts as contributing none: its scripts
- * still load, since whatever else the provider does may need them.
- */
-export function collectProviderScriptsWithoutComponents(modules, registrations) {
-    const providersWithComponents = new Set();
-    for (const registration of registrations)
-        providersWithComponents.add(registration.providerRef);
-    return collectDeclaredProviderScripts([...modules].filter((module) => !providersWithComponents.has(module.metadata.ref)));
+    contributedLoaders = new Map();
 }
 //# sourceMappingURL=provider-component-registry.frontend.service.js.map

package/dist/esm/core/components-registry/provider-component-registry.frontend.service.js.map

@@ -1 +1 @@
-{"version":3,"file":"provider-component-registry.frontend.service.js","sourceRoot":"","sources":["../../../../../src/core/components-registry/provider-component-registry.frontend.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Components contributed by PROVIDERS, keyed by the capability each fills.\n *\n * ## Why this is a sibling of `ComponentRegistryService` and not an extension\n *\n * The two answer different questions, and the difference is in the KEY, the\n * cardinality and the lifecycle — not in whether a vocabulary is open:\n *\n *   - `ComponentRegistryService` keys `componentType:preset[:category]`, where\n *     `FrontendComponentType` is a CLOSED enum the engine owns. Exactly one\n *     component answers a key, resolution is synchronous, and a missing\n *     registration is a startup refusal.\n *   - This registry keys `capability:providerRef`. The capability half is\n *     closed too (`ProviderCapability` is the built-in set since #502 removed\n *     module augmentation), but the PROVIDER half is not engine-owned at all:\n *     refs arrive from engine modules, generated packages and application\n *     packages, discovered per deployment. SEVERAL providers may answer one\n *     capability, the component arrives asynchronously, and none of it is\n *     required for the app to mount.\n *\n * Forcing provider components through `FrontendComponentType` would mean an\n * engine enum member per capability and a preset per provider, and would make \"which component\n * answers this key\" ambiguous in a registry whose whole contract is that it is\n * not. (This paragraph used to justify the split by calling `ProviderCapability`\n * OPEN; that stopped being true with #502, and the split stands on the reasons\n * above.)\n *\n * It also keeps the blast radius honest. `ComponentRegistryService` has sixteen\n * consumers across four packages (re-measured 2026-09-06; the plan's figure of\n * eleven predates several of them), most of them outside this slice's territory.\n * A sibling registry touches none of them.\n *\n * ## Several providers, and no silent winner\n *\n * `listProviders` returns every provider offering a component for a capability,\n * in registration order, and nothing here picks one. That is deliberate: the\n * defect being fixed is that resolution WAS first-match, so a Drive picker and\n * a Dropbox picker could not coexist and the winner depended on map order. A\n * surface with two providers has a choice to present; a registry that answered\n * it would be making a product decision in a lookup table.\n */\n\nimport type React from 'react';\nimport type { ProviderCapability } from '@wildo-ai/saas-models';\nimport type {\n  ProviderFrontendComponentDescriptor,\n  ProviderFrontendScriptDeclaration,\n} from '@wildo-ai/saas-models/public-runtime';\nimport {\n  collectDeclaredProviderScripts,\n  loadProviderScripts,\n  type DeclaredProviderScript,\n  type ProviderScriptLoadOutcome,\n} from '@wildo-ai/external-connectors-public/app';\n\nimport { describeCaughtError } from '@wildo-ai/saas-models';\n/** A loader as a provider module declares it: on demand, returning the component. */\nexport type ProviderComponentLoader = () => Promise<unknown>;\n\n/** Why a provider component could not be registered or loaded. */\nexport enum ProviderComponentDiagnosticKind {\n  /**\n   * A second registration arrived for one capability AND provider. The first is\n   * kept: a duplicate is a wiring mistake, and swapping the live component\n   * under a mounted surface would be worse than ignoring it.\n   */\n  DUPLICATE_REGISTRATION = 'DUPLICATE_REGISTRATION',\n  /** The loader threw or rejected. That provider's component is unavailable; others are not affected. */\n  LOAD_FAILED = 'LOAD_FAILED',\n  /**\n   * The loader resolved something that is not a component. Almost always a\n   * loader returning a MODULE NAMESPACE — `() => import('./Picker')` — where it\n   * should return the component itself.\n   */\n  LOADED_VALUE_IS_NOT_A_COMPONENT = 'LOADED_VALUE_IS_NOT_A_COMPONENT',\n  /**\n   * A live provider DECLARES a component for a capability and nothing supplies\n   * its loader — neither the module (`components[cap].load`) nor the facet\n   * library (`contributeProviderComponentLoaders`). The declaration is DATA a\n   * reviewer can read; without code behind it the chooser would offer a picker\n   * that cannot open. Not registered, and reported once at startup.\n   */\n  DECLARED_WITHOUT_LOADER = 'DECLARED_WITHOUT_LOADER',\n  /**\n   * BOTH the module and the facet library supplied a loader for one\n   * `capability:providerRef`. The module's wins — it is the provider's own\n   * word — and the collision is reported, because the engine never authors both\n   * and two loaders for one declaration is the map-order ambiguity #380 removed.\n   */\n  LOADER_SUPPLIED_TWICE = 'LOADER_SUPPLIED_TWICE',\n  /**\n   * A `<script>` the declaring provider needs did not load — a network failure,\n   * a Content-Security-Policy refusal, or an integrity mismatch. The component\n   * resolves `null`, and that answer is CACHED exactly like `LOAD_FAILED`: the\n   * failed element stays in the document and is not retried this session (a\n   * vendor script can fail after partially executing, and a second copy could\n   * initialise over the first), so a chooser re-rendering must not re-ask. A\n   * component whose vendor global is absent is not usable, and handing it back\n   * would only move the failure into its own mount (\"The Google API script has\n   * not loaded\"), where nothing can name the provider's declaration as the cause.\n   */\n  SCRIPT_LOAD_FAILED = 'SCRIPT_LOAD_FAILED',\n}\n\nexport interface ProviderComponentDiagnostic {\n  readonly kind: ProviderComponentDiagnosticKind;\n  readonly capability: string;\n  readonly providerRef: string;\n  readonly message: string;\n  readonly cause?: unknown;\n}\n\nexport interface ProviderComponentRegistration {\n  readonly capability: ProviderCapability;\n  readonly providerRef: string;\n  readonly load: ProviderComponentLoader;\n  /**\n   * What the provider DECLARED about this component — today, what a selection\n   * from it contains. Kept beside the loader rather than looked up from the\n   * DATA entry at the use site, because a surface needs it BEFORE it decides to\n   * load anything, and because the two would then be two sources for one fact.\n   */\n  readonly descriptor: ProviderFrontendComponentDescriptor;\n  /**\n   * The third-party `<script>` tags the DECLARING PROVIDER needs (its module's\n   * `scripts`), loaded before the component is handed back. Carried on the\n   * registration because a provider's scripts load when its code first runs on\n   * this surface — with its component, when it contributes one — so no page pays\n   * for a vendor loader nobody opened. Absent means the component depends on no\n   * script.\n   */\n  readonly scripts?: ReadonlyArray<ProviderFrontendScriptDeclaration>;\n}\n\n/**\n * Loads a provider's declared scripts and resolves once each has executed or\n * failed. Never rejects: failures come back in the outcome.\n */\nexport type ProviderComponentScriptLoader = (\n  scripts: ReadonlyArray<DeclaredProviderScript>,\n) => Promise<ProviderScriptLoadOutcome>;\n\n/**\n * The default script loader: the shared `loadProviderScripts` against the live\n * `document`, read at CALL time rather than at registry construction. No\n * `typeof document` guard: this package is pure-frontend (engine rule), and a\n * host with no DOM injects its own `loadScripts`.\n */\nconst loadProviderScriptsIntoDocument: ProviderComponentScriptLoader = (scripts) => loadProviderScripts(scripts, document);\n\n/** A component type this registry will hand back once loaded. */\nexport type ProviderComponent = React.ComponentType<never>;\n\nexport interface ProviderComponentRegistry {\n  /**\n   * Every provider offering a component for this capability, in registration\n   * order. Synchronous ON PURPOSE: a surface has to render its chooser before\n   * any component is loaded, and awaiting here would make an empty frame.\n   */\n  listProviders(capability: ProviderCapability): ReadonlyArray<string>;\n  /** Whether this exact provider offers a component for this capability. */\n  has(capability: ProviderCapability, providerRef: string): boolean;\n  /**\n   * What the provider declared about its component, without loading it —\n   * `undefined` when this provider offers none for this capability.\n   *\n   * Synchronous and separate from `resolve` on purpose: the framework routes a\n   * selection according to what was DECLARED, and a routing decision that had to\n   * await a download would mean downloading a picker to find out whether the\n   * surface can use it.\n   */\n  describe(capability: ProviderCapability, providerRef: string): ProviderFrontendComponentDescriptor | undefined;\n  /**\n   * Loads one provider's component AND the scripts its provider declares, in\n   * parallel, and hands the component back only once both are present — a\n   * component is usable only once what it depends on is. The loader runs at most\n   * once per pair — a chooser that mounts and unmounts must not re-download a\n   * picker — and a failure of either half is reported and returns `null` rather\n   * than throwing into a render.\n   */\n  resolve(capability: ProviderCapability, providerRef: string): Promise<ProviderComponent | null>;\n}\n\nfunction isModuleNamespace(value: unknown): boolean {\n  return (\n    typeof value === 'object'\n    && value !== null\n    && (value as { [Symbol.toStringTag]?: unknown })[Symbol.toStringTag] === 'Module'\n  );\n}\n\n/**\n * A React component is a function, or an object for `memo` / `forwardRef` /\n * `lazy`. Anything else — a namespace, a string, a plain data object — cannot\n * be rendered, and finding out at render time means a blank surface with a\n * stack trace pointing at React rather than at the provider.\n */\nfunction looksLikeComponent(value: unknown): value is ProviderComponent {\n  return typeof value === 'function' || (typeof value === 'object' && value !== null);\n}\n\nexport function createProviderComponentRegistry(input?: {\n  readonly registrations?: Iterable<ProviderComponentRegistration>;\n  readonly onDiagnostic?: (diagnostic: ProviderComponentDiagnostic) => void;\n  /**\n   * How declared scripts are loaded. Defaults to the shared injector on the live\n   * `document`; injectable so a test can settle a script without a network and a\n   * non-DOM host can say what loading means for it.\n   */\n  readonly loadScripts?: ProviderComponentScriptLoader;\n}): ProviderComponentRegistry {\n  const raise = (diagnostic: ProviderComponentDiagnostic): void => {\n    input?.onDiagnostic?.(diagnostic);\n  };\n  const loaders = new Map<string, ProviderComponentLoader>();\n  const scriptsByKey = new Map<string, ReadonlyArray<ProviderFrontendScriptDeclaration>>();\n  const loadScripts = input?.loadScripts ?? loadProviderScriptsIntoDocument;\n  const descriptors = new Map<string, ProviderFrontendComponentDescriptor>();\n  const byCapability = new Map<string, string[]>();\n  const loaded = new Map<string, Promise<ProviderComponent | null>>();\n  const keyOf = (capability: string, providerRef: string): string => `${capability}:${providerRef}`;\n\n  for (const registration of input?.registrations ?? []) {\n    const key = keyOf(registration.capability, registration.providerRef);\n    if (loaders.has(key)) {\n      raise({\n        kind: ProviderComponentDiagnosticKind.DUPLICATE_REGISTRATION,\n        capability: registration.capability,\n        providerRef: registration.providerRef,\n        message:\n          `Provider \"${registration.providerRef}\" registered a component for \"${registration.capability}\" `\n          + 'more than once. The first registration is kept.',\n      });\n      continue;\n    }\n\n    loaders.set(key, registration.load);\n    if (registration.scripts !== undefined && registration.scripts.length > 0) {\n      scriptsByKey.set(key, registration.scripts);\n    }\n    descriptors.set(key, registration.descriptor);\n    const providers = byCapability.get(registration.capability) ?? [];\n    providers.push(registration.providerRef);\n    byCapability.set(registration.capability, providers);\n  }\n\n  return {\n    listProviders(capability) {\n      return byCapability.get(capability) ?? [];\n    },\n\n    has(capability, providerRef) {\n      return loaders.has(keyOf(capability, providerRef));\n    },\n\n    describe(capability, providerRef) {\n      return descriptors.get(keyOf(capability, providerRef));\n    },\n\n    resolve(capability, providerRef) {\n      const key = keyOf(capability, providerRef);\n      const cached = loaded.get(key);\n      if (cached !== undefined) return cached;\n\n      const load = loaders.get(key);\n      if (load === undefined) return Promise.resolve(null);\n\n      const declaredScripts = scriptsByKey.get(key) ?? [];\n\n      const pending = (async (): Promise<ProviderComponent | null> => {\n        // Both halves start together: the picker chunk and the vendor loader are\n        // independent downloads, and serialising them would make every first\n        // open wait for their SUM instead of the slower of the two.\n        //\n        // Each half is started through `Promise.resolve().then(...)` so a loader\n        // that throws SYNCHRONOUSLY is still a reported failure rather than an\n        // exception escaping `resolve`, and a script loader that breaks its\n        // never-rejects contract is still a SCRIPT_LOAD_FAILED rather than an\n        // unhandled rejection in a render path.\n        const scriptsToLoad: ReadonlyArray<DeclaredProviderScript> = declaredScripts.map((declaration) => ({ providerRef, declaration }));\n        const [componentResult, scriptOutcome] = await Promise.all([\n          Promise.resolve().then(load).then(\n            (value): { readonly ok: true; readonly value: unknown } => ({ ok: true, value }),\n            (cause: unknown): { readonly ok: false; readonly cause: unknown } => ({ ok: false, cause }),\n          ),\n          scriptsToLoad.length === 0\n            ? Promise.resolve<ProviderScriptLoadOutcome | undefined>(undefined)\n            : Promise.resolve().then(() => loadScripts(scriptsToLoad)).catch((cause: unknown): ProviderScriptLoadOutcome => ({\n              loaded: [],\n              failed: scriptsToLoad.map(({ declaration }) => ({\n                providerRef,\n                src: declaration.src,\n                message: `The script loader failed before reporting an outcome: ${describeCaughtError(cause)}`,\n              })),\n            })),\n        ]);\n\n        // Reported independently so a first open that fails on BOTH halves names\n        // both causes, rather than making the second one visible only after the\n        // first is fixed.\n        for (const failure of scriptOutcome?.failed ?? []) {\n          raise({\n            kind: ProviderComponentDiagnosticKind.SCRIPT_LOAD_FAILED,\n            capability,\n            providerRef,\n            message:\n              `Provider \"${providerRef}\" cannot offer its \"${capability}\" component: a script it declares did not load. `\n              + failure.message,\n          });\n        }\n\n        if (componentResult.ok === false) {\n          raise({\n            kind: ProviderComponentDiagnosticKind.LOAD_FAILED,\n            capability,\n            providerRef,\n            message: `Provider \"${providerRef}\" failed to load its \"${capability}\" component.`,\n            cause: componentResult.cause,\n          });\n          return null;\n        }\n\n        if ((scriptOutcome?.failed.length ?? 0) > 0) return null;\n\n        const value = componentResult.value;\n\n        if (isModuleNamespace(value)) {\n          raise({\n            kind: ProviderComponentDiagnosticKind.LOADED_VALUE_IS_NOT_A_COMPONENT,\n            capability,\n            providerRef,\n            message:\n              `Provider \"${providerRef}\" returned a MODULE for its \"${capability}\" component instead of the `\n              + \"component itself. Write `async () => (await import('./Picker')).Picker` rather than \"\n              + \"`() => import('./Picker')`.\",\n          });\n          return null;\n        }\n\n        if (!looksLikeComponent(value)) {\n          raise({\n            kind: ProviderComponentDiagnosticKind.LOADED_VALUE_IS_NOT_A_COMPONENT,\n            capability,\n            providerRef,\n            message:\n              `Provider \"${providerRef}\" returned a ${typeof value} for its \"${capability}\" component. A React `\n              + 'component is a function, or an object for memo / forwardRef / lazy.',\n          });\n          return null;\n        }\n\n        return value;\n      })();\n\n      // Cached even when it resolves to null: a loader — or a script — that failed\n      // once must not be retried on every render of a chooser that lists it.\n      loaded.set(key, pending);\n      return pending;\n    },\n  };\n}\n\n/** The shape this derivation needs off a hydrated provider module. */\ninterface ComponentBearingProviderModule {\n  metadata: { ref: string };\n  scripts?: ReadonlyArray<ProviderFrontendScriptDeclaration>;\n  components?: Readonly<Record<string, ProviderFrontendComponentDescriptor & { load?: ProviderComponentLoader }>>;\n}\n\n/**\n * A loader the FACET LIBRARY supplies for a component a provider module\n * declares — the second of the two doors, and the one every engine-shipped\n * component uses (#394).\n *\n * The provider module, in `@wildo-ai/external-connectors-public`, declares the\n * DATA half (`components[cap].selectionDelivery`) and cannot name a loader that\n * reaches a React component: that package is deliberately renderer-free, and it\n * sits BELOW the component libraries in the layering, so a dynamic import from\n * it would close a package cycle. The library that owns the component\n * (`presets-components` for the app facet) contributes the loader here instead,\n * from the same place it registers its presets. A provider PACKAGE that ships\n * its own component still uses `components[cap].load` — both doors exist, the\n * engine authors exactly one per declaration, and a collision is reported.\n */\nexport interface ProviderComponentLoaderContribution {\n  readonly capability: ProviderCapability;\n  readonly providerRef: string;\n  readonly load: ProviderComponentLoader;\n}\n\nconst contributedLoaders = new Map<string, ProviderComponentLoaderContribution>();\nconst loaderKeyOf = (capability: string, providerRef: string): string => `${capability}:${providerRef}`;\n\n/**\n * Registers loaders for provider components a facet library ships. Module-level\n * and idempotent per key, like `ComponentRegistryService.register`: the app\n * calls the library's registration entry once at startup, and a second\n * contribution for one key replaces the first rather than duplicating it —\n * the library is one author, and the last thing it said is what it means.\n *\n * A contribution for a provider the DATA channel does not declare live is\n * SILENT, by the same rule as code without data in `hydrateFrontendProviderModules`:\n * a bundle legitimately ships a picker an environment leaves off.\n */\nexport function contributeProviderComponentLoaders(loaders: Iterable<ProviderComponentLoaderContribution>): void {\n  for (const loader of loaders) {\n    contributedLoaders.set(loaderKeyOf(loader.capability, loader.providerRef), loader);\n  }\n}\n\n/** Every contributed loader, keyed `capability:providerRef`. Read at registry construction. */\nexport function listContributedProviderComponentLoaders(): ReadonlyMap<string, ProviderComponentLoaderContribution> {\n  return contributedLoaders;\n}\n\n/** Tests only: forget every contributed loader. */\nexport function _clearContributedProviderComponentLoaders(): void {\n  contributedLoaders.clear();\n}\n\n/**\n * Turns the live provider modules into registrations, joining each declared\n * component to its loader — from the module when it carries one, else from\n * the facet library's contributions.\n *\n * Order follows the registry's iteration order, which is the order the service\n * declared its providers — so `listProviders` is stable across reloads and a\n * surface that shows a chooser does not reorder itself between renders.\n *\n * A declaration nothing can load is NOT registered: a chooser must offer only\n * what can render. It is reported through `onDiagnostic` instead, once, at\n * startup — which is the moment somebody can still fix it.\n */\nexport function collectProviderComponentRegistrations(\n  modules: Iterable<ComponentBearingProviderModule>,\n  input?: {\n    readonly contributedLoaders?: ReadonlyMap<string, ProviderComponentLoaderContribution>;\n    readonly onDiagnostic?: (diagnostic: ProviderComponentDiagnostic) => void;\n  },\n): ProviderComponentRegistration[] {\n  const registrations: ProviderComponentRegistration[] = [];\n  const contributed = input?.contributedLoaders ?? listContributedProviderComponentLoaders();\n\n  for (const module of modules) {\n    for (const [capability, declaration] of Object.entries(module.components ?? {})) {\n      const providerRef = module.metadata.ref;\n      const supplied = contributed.get(loaderKeyOf(capability, providerRef));\n\n      if (declaration.load !== undefined && supplied !== undefined) {\n        input?.onDiagnostic?.({\n          kind: ProviderComponentDiagnosticKind.LOADER_SUPPLIED_TWICE,\n          capability,\n          providerRef,\n          message:\n            `Provider \"${providerRef}\" carries its own loader for \"${capability}\" AND the facet library contributed `\n            + \"one. The module's is used; remove one of the two.\",\n        });\n      }\n\n      const load = declaration.load ?? supplied?.load;\n      if (load === undefined) {\n        input?.onDiagnostic?.({\n          kind: ProviderComponentDiagnosticKind.DECLARED_WITHOUT_LOADER,\n          capability,\n          providerRef,\n          message:\n            `Provider \"${providerRef}\" declares a \"${capability}\" component and nothing supplies its loader — `\n            + 'neither the module nor the facet library. It is not offered. An engine-shipped component is '\n            + 'registered by the facet library (presets-components for the app); a provider package supplies '\n            + '`components[capability].load`.',\n        });\n        continue;\n      }\n\n      registrations.push({\n        capability: capability as ProviderCapability,\n        providerRef,\n        load,\n        // Only the declared half, never the whole declaration: `load` is already\n        // carried beside it, and a registration holding the same function twice\n        // is two places for one fact to go stale.\n        descriptor: { selectionDelivery: declaration.selectionDelivery },\n        // The PROVIDER's scripts, not the component's: a module declares scripts\n        // once, and the component is the first of its code to run on this surface\n        // — so it is what they load with.\n        ...(module.scripts !== undefined && module.scripts.length > 0 ? { scripts: module.scripts } : {}),\n      });\n    }\n  }\n\n  return registrations;\n}\n\n/**\n * The scripts a surface must load at STARTUP: those declared by live providers that\n * contribute NO registered component.\n *\n * A provider's scripts load when its code first runs on the surface. A provider with a\n * registered component has that moment — the registry loads its scripts when the\n * component is first resolved, so no page pays for a picker's vendor loader nobody\n * opened. A provider without one never will, so its scripts load at startup, the same\n * population rule SDK activation uses. A provider that DECLARES a component nothing\n * can load is not registered and therefore counts as contributing none: its scripts\n * still load, since whatever else the provider does may need them.\n */\nexport function collectProviderScriptsWithoutComponents(\n  modules: Iterable<ComponentBearingProviderModule>,\n  registrations: Iterable<ProviderComponentRegistration>,\n): ReadonlyArray<DeclaredProviderScript> {\n  const providersWithComponents = new Set<string>();\n  for (const registration of registrations) providersWithComponents.add(registration.providerRef);\n  return collectDeclaredProviderScripts(\n    [...modules].filter((module) => !providersWithComponents.has(module.metadata.ref)),\n  );\n}\n"]}
+{"version":3,"file":"provider-component-registry.frontend.service.js","sourceRoot":"","sources":["../../../../../src/core/components-registry/provider-component-registry.frontend.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAOH,OAAO,EAAE,yCAAyC,EAAE,MAAM,0CAA0C,CAAC;AAQrG,IAAI,kBAAkB,GAA6D,IAAI,GAAG,EAAE,CAAC;AAE7F;;;;;;;;;GASG;AACH,MAAM,UAAU,kCAAkC,CAAC,OAAsD;IACvG,kBAAkB,GAAG,yCAAyC,CAAC,CAAC,GAAG,kBAAkB,CAAC,MAAM,EAAE,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC;AAC/G,CAAC;AAED,+FAA+F;AAC/F,MAAM,UAAU,uCAAuC;IACrD,OAAO,kBAAkB,CAAC;AAC5B,CAAC;AAED,mDAAmD;AACnD,MAAM,UAAU,yCAAyC;IACvD,kBAAkB,GAAG,IAAI,GAAG,EAAE,CAAC;AACjC,CAAC","sourcesContent":["/**\n * The APPLICATION's half of the provider-component registry.\n *\n * The registry itself — keyed `capability:providerRef`, consent-gated, script-before-component,\n * browser-only — lives in `@wildo-ai/external-connectors-public` since #1703, because the website\n * and the documentation site have to build the same registry from the same `components`\n * declaration and neither may import this package. Read its module header\n * (`createProviderComponentRegistry`) for why it is a sibling of `ComponentRegistryService` and why\n * it never picks a provider.\n *\n * What stays here is what only the application has:\n *\n *   - the component TYPE the application renders (`ProviderComponent`), which fills the shared\n *     registry's type parameter;\n *   - the application's facet-library door, `contributeProviderComponentLoaders`, through which\n *     `presets-components` supplies loaders for engine-shipped components (#394). It is module-level\n *     state on purpose: `registerDefaultPresets` runs before `startApplication` builds the registry,\n *     the same ordering `ComponentRegistryService.register` relies on. The website and the\n *     documentation site take the same contributions as an explicit input instead, because their\n *     wiring has a single construction site that can carry it.\n */\n\nimport type React from 'react';\nimport type {\n  ProviderComponentLoaderContribution,\n  ProviderComponentRegistry,\n} from '@wildo-ai/external-connectors-public/app';\nimport { indexProviderComponentLoaderContributions } from '@wildo-ai/external-connectors-public/app';\n\n/** A component type the application's registry hands back once loaded. */\nexport type ProviderComponent = React.ComponentType<never>;\n\n/** The application's provider-component registry: the shared registry, holding React components. */\nexport type AppProviderComponentRegistry = ProviderComponentRegistry<ProviderComponent>;\n\nlet contributedLoaders: ReadonlyMap<string, ProviderComponentLoaderContribution> = new Map();\n\n/**\n * Registers loaders for provider components a facet library ships. Module-level and idempotent per\n * key, like `ComponentRegistryService.register`: the app calls the library's registration entry once\n * at startup, and a second contribution for one key replaces the first rather than duplicating it —\n * the library is one author, and the last thing it said is what it means.\n *\n * A contribution for a provider the DATA channel does not declare live is SILENT, by the same rule\n * as code without data in `hydrateFrontendProviderModules`: a bundle legitimately ships a picker an\n * environment leaves off.\n */\nexport function contributeProviderComponentLoaders(loaders: Iterable<ProviderComponentLoaderContribution>): void {\n  contributedLoaders = indexProviderComponentLoaderContributions([...contributedLoaders.values(), ...loaders]);\n}\n\n/** Every contributed loader, keyed `capability:providerRef`. Read at registry construction. */\nexport function listContributedProviderComponentLoaders(): ReadonlyMap<string, ProviderComponentLoaderContribution> {\n  return contributedLoaders;\n}\n\n/** Tests only: forget every contributed loader. */\nexport function _clearContributedProviderComponentLoaders(): void {\n  contributedLoaders = new Map();\n}\n"]}

package/dist/esm/core/components-registry/useProviderComponent.frontend.hooks.d.ts

@@ -23,6 +23,7 @@
  */
 import type { ProviderCapability } from '@wildo-ai/saas-models';
 import type { FileStorageAccepted } from '@wildo-ai/saas-models/public-runtime';
+import { type ProviderComponentLoadState } from '@wildo-ai/external-connectors-public/app';
 import type { ProviderComponent } from './provider-component-registry.frontend.service';
 export interface ProviderComponentChoice {
     readonly providerRef: string;
@@ -48,36 +49,25 @@ export interface ProviderComponentChoice {
  * render.
  */
 export declare function useProviderComponentChoices(capability: ProviderCapability): ReadonlyArray<ProviderComponentChoice>;
-/** Why a provider component is not on screen yet. */
-export declare enum ProviderComponentStatus {
-    /** No provider was chosen, or none offers a component for this capability. */
-    NONE = "NONE",
-    /** The component, or a script its provider declares, is still downloading. */
-    LOADING = "LOADING",
-    /**
-     * The component is loaded AND every `<script>` its provider declares has
-     * executed — so a picker that reads a vendor global on mount finds it. Never
-     * READY on the component alone.
-     */
-    READY = "READY",
-    /**
-     * The loader failed, returned something unrenderable, or a script the provider
-     * declares did not load. The registry has already reported why; a surface
-     * should fall back rather than retry, because the registry will not run a
-     * failed loader — or re-inject a failed script — again.
-     */
-    UNAVAILABLE = "UNAVAILABLE"
-}
-export interface ProviderComponentState {
-    readonly status: ProviderComponentStatus;
-    readonly Component: ProviderComponent | null;
-}
+/**
+ * What `useProviderComponent` returns: the shared load state (#1703), holding the application's
+ * component type. The status vocabulary — `ProviderComponentStatus` — is the ONE the website and the
+ * documentation site use too, exported from `@wildo-ai/external-connectors-public/app`.
+ */
+export type ProviderComponentState = ProviderComponentLoadState<ProviderComponent>;
 /**
  * Loads one provider's component for a capability.
  *
- * Pass `undefined` for the ref while nothing is chosen — the hook does not
- * choose, and a surface with several providers must not load all of them
- * speculatively.
+ * Pass `undefined` for the ref while nothing is chosen — the hook does not choose, and a surface with
+ * several providers must not load all of them speculatively.
+ *
+ * The decision itself (consent first, then load, then READY / UNAVAILABLE, and a cancelled answer
+ * never overwriting a later choice) is `startProviderComponentLoad`, shared with the website and the
+ * documentation site so the three surfaces cannot come to disagree about it. This hook supplies the
+ * application's two inputs: the registry built at startup, and the signed-in person's grant.
+ * `ProviderComponentStatus.CONSENT_REQUIRED` means NOTHING of the provider was downloaded; a surface
+ * renders a consent-required state there, never a blank, and granting reloads it without a re-mount,
+ * because the hook re-evaluates when the grant changes.
  */
 export declare function useProviderComponent(capability: ProviderCapability, providerRef: string | undefined): ProviderComponentState;
 //# sourceMappingURL=useProviderComponent.frontend.hooks.d.ts.map

package/dist/esm/core/components-registry/useProviderComponent.frontend.hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useProviderComponent.frontend.hooks.d.ts","sourceRoot":"","sources":["../../../../../src/core/components-registry/useProviderComponent.frontend.hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAGhF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gDAAgD,CAAC;AAExF,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,kFAAkF;IAClF,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,mBAAmB,CAAC;CAC5C;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,kBAAkB,GAC7B,aAAa,CAAC,uBAAuB,CAAC,CAexC;AAED,qDAAqD;AACrD,oBAAY,uBAAuB;IACjC,8EAA8E;IAC9E,IAAI,SAAS;IACb,8EAA8E;IAC9E,OAAO,YAAY;IACnB;;;;OAIG;IACH,KAAK,UAAU;IACf;;;;;OAKG;IACH,WAAW,gBAAgB;CAC5B;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,iBAAiB,GAAG,IAAI,CAAC;CAC9C;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,kBAAkB,EAC9B,WAAW,EAAE,MAAM,GAAG,SAAS,GAC9B,sBAAsB,CAiCxB"}
+{"version":3,"file":"useProviderComponent.frontend.hooks.d.ts","sourceRoot":"","sources":["../../../../../src/core/components-registry/useProviderComponent.frontend.hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAGL,KAAK,0BAA0B,EAChC,MAAM,0CAA0C,CAAC;AAIlD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gDAAgD,CAAC;AAExF,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,kFAAkF;IAClF,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,mBAAmB,CAAC;CAC5C;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,kBAAkB,GAC7B,aAAa,CAAC,uBAAuB,CAAC,CAexC;AAED;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,0BAA0B,CAAC,iBAAiB,CAAC,CAAC;AAEnF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,kBAAkB,EAC9B,WAAW,EAAE,MAAM,GAAG,SAAS,GAC9B,sBAAsB,CAuBxB"}

package/dist/esm/core/components-registry/useProviderComponent.frontend.hooks.js

@@ -22,8 +22,10 @@
  * translation invisible.
  */
 import { useEffect, useState } from 'react';
+import { idleProviderComponentLoadState, startProviderComponentLoad, } from '@wildo-ai/external-connectors-public/app';
 import { buildProviderDisplayNameLabelKey } from '@wildo-ai/saas-models/public-runtime';
 import { useApplication } from '../../core/runtime/useApplication.js';
+import { useGrantedConsentPurposes } from '../../core/security/useGrantedConsentPurposes.js';
 /**
  * The providers that are BOTH live for this service and carry a component for
  * this capability.
@@ -47,60 +49,38 @@ export function useProviderComponentChoices(capability) {
         };
     });
 }
-/** Why a provider component is not on screen yet. */
-export var ProviderComponentStatus;
-(function (ProviderComponentStatus) {
-    /** No provider was chosen, or none offers a component for this capability. */
-    ProviderComponentStatus["NONE"] = "NONE";
-    /** The component, or a script its provider declares, is still downloading. */
-    ProviderComponentStatus["LOADING"] = "LOADING";
-    /**
-     * The component is loaded AND every `<script>` its provider declares has
-     * executed — so a picker that reads a vendor global on mount finds it. Never
-     * READY on the component alone.
-     */
-    ProviderComponentStatus["READY"] = "READY";
-    /**
-     * The loader failed, returned something unrenderable, or a script the provider
-     * declares did not load. The registry has already reported why; a surface
-     * should fall back rather than retry, because the registry will not run a
-     * failed loader — or re-inject a failed script — again.
-     */
-    ProviderComponentStatus["UNAVAILABLE"] = "UNAVAILABLE";
-})(ProviderComponentStatus || (ProviderComponentStatus = {}));
 /**
  * Loads one provider's component for a capability.
  *
- * Pass `undefined` for the ref while nothing is chosen — the hook does not
- * choose, and a surface with several providers must not load all of them
- * speculatively.
+ * Pass `undefined` for the ref while nothing is chosen — the hook does not choose, and a surface with
+ * several providers must not load all of them speculatively.
+ *
+ * The decision itself (consent first, then load, then READY / UNAVAILABLE, and a cancelled answer
+ * never overwriting a later choice) is `startProviderComponentLoad`, shared with the website and the
+ * documentation site so the three surfaces cannot come to disagree about it. This hook supplies the
+ * application's two inputs: the registry built at startup, and the signed-in person's grant.
+ * `ProviderComponentStatus.CONSENT_REQUIRED` means NOTHING of the provider was downloaded; a surface
+ * renders a consent-required state there, never a blank, and granting reloads it without a re-mount,
+ * because the hook re-evaluates when the grant changes.
  */
 export function useProviderComponent(capability, providerRef) {
     const { providerComponentRegistry } = useApplication();
-    const [state, setState] = useState({
-        status: ProviderComponentStatus.NONE,
-        Component: null,
-    });
-    useEffect(() => {
-        if (providerComponentRegistry === undefined || providerRef === undefined) {
-            setState({ status: ProviderComponentStatus.NONE, Component: null });
-            return;
-        }
-        let current = true;
-        setState({ status: ProviderComponentStatus.LOADING, Component: null });
-        void providerComponentRegistry.resolve(capability, providerRef).then((Component) => {
-            // A user can switch provider while one is still downloading. Without this
-            // the slower answer would arrive last and replace the one they chose.
-            if (!current)
-                return;
-            setState(Component === null
-                ? { status: ProviderComponentStatus.UNAVAILABLE, Component: null }
-                : { status: ProviderComponentStatus.READY, Component });
-        });
-        return () => {
-            current = false;
-        };
-    }, [capability, providerRef, providerComponentRegistry]);
+    // The signed-in person's grant (#1702). Keyed by value below, so an unrelated preference change does not
+    // re-run the load.
+    const { granted } = useGrantedConsentPurposes();
+    const grantedKey = granted.join(',');
+    const [state, setState] = useState(() => idleProviderComponentLoadState());
+    useEffect(() => startProviderComponentLoad({
+        registry: providerComponentRegistry,
+        capability,
+        providerRef,
+        grantedConsentPurposes: granted,
+        onState: setState,
+    }), 
+    // `granted` is read through `grantedKey`: its identity changes with every preferences object, its
+    // meaning only when the set changes.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [capability, providerRef, providerComponentRegistry, grantedKey]);
     return state;
 }
 //# sourceMappingURL=useProviderComponent.frontend.hooks.js.map