@jfdevelops/react-layout 1.6.1 → 2.0.0

package/dist/index.d.mts

@@ -1,3 +1,7 @@
+import { LayoutConfigurationError, LayoutConfigurationErrorContext } from "./errors/layout-configuration-error.mjs";
+import { ResourceModuleLoadError, ResourceRenderError, ResourceStateError } from "./errors/resource-state-error.mjs";
+import { LazyResourceError, LazyResourceErrorMap, LazyResourceModuleShapeError, LazyResourceStateNotFoundError, isLazyResourceError } from "./errors/lazy-resource-error.mjs";
+import { CreateLazyErrorComponent, LazyErrorHandlers, LazyHandle, LazyOptions, LazyResourceErrorComponent, LazyResourceErrorProps, LazyResourceLoadingComponent, LazyResourceStates, LoadStatus } from "./lazy/types.mjs";
 import { BaseComponent, MergeIntersection, Show, UnionToIntersection, pick } from "./utils.mjs";
 import { LayoutResourceKey, NormalizeResource, NormalizeResources, NormalizedResourceDefinition, NormalizedResourceDefinitions, ResourceDefinition, ResourceDefinitionValue, ResourceEnum, ResourceLayoutComponentProps, ResourcePath, ResourceTree, normalizeResource, normalizeResourceDefinitions, normalizeResources, toResourceEnum } from "./resource.mjs";
 import { InPropsDefinition, InPropsFunction, InPropsObject, InPropsOptions, IncludedComponentPropDefinitions, IncludedPropBehavior, IncludedProps, InferredInProps, LayoutRenderProps, MergedLayoutInProps, PropsContextRender, PropsRenderDefinition, ResolvedIncludedComponentProps, ResolvedIncludedConfigProps, ResolvedIncludedProps, ResolvedIncludedPropsAsDefined } from "./props.mjs";
@@ -10,8 +14,9 @@ import { ForPaths, ForPathsRenderContext, RenderedPathComponent, RenderedPathCom
 import { IsSubResourceKey } from "./create-config/is-sub-resource-key.mjs";
 import { ComponentTypes, CreateResourceConfigFn, CreateResourceConfigForResource, CreatedResourceConfig, ResourceConfigFragment } from "./create-config/get-component.mjs";
 import { CreateResourceMap, CreateResourceMapFn } from "./create-config/create-resource-links.mjs";
+import { ScopedComponentRenderFn } from "./lazy/scoped-content.mjs";
 import { ContextualInlineRenderState, ContextualInlineRenderStates, CreateResourceLayoutWithLayoutOptions, CreateViewMapBuiltInRenderStatesOptions, CreateViewMapFunctionRenderOptions, CreateViewMapInlineRenderStatesOptions, CreateViewMapRenderStatesOptions, DefineResourceLayoutWithLayoutFn, DefineResourcesFn, DefinedResourceLayoutWithShell, LayoutRenderResourcesAccessor, LayoutResourcesAccessor, ResourceLayoutProvider, ResourceLayoutProviderProps, ResourceLayoutShellComponent, ResourceLayoutShellProps, ResourceSelection, ShellLayoutDefinition, ShellRenderContext, TypedBuiltInRenderStates, TypedInlineRenderState, defineResourceLayout } from "./create-config/define-layout.mjs";
-import { LazyResourceErrorComponent, LazyResourceLayoutComponent, LazyResourceLayoutOptions, LazyResourceLoadingComponent, LazyResourceStates } from "./create-config/lazy-resource-layout.mjs";
+import { LazyResourceLayoutComponent, LazyResourceLayoutOptions } from "./create-config/lazy-resource-layout.mjs";
 import { BoundDefineResourceLayout, CreateDefinedResourceLayoutOptions, CreateDefinedResourceLayoutResult, DefineLazyDefaults, DefinedResourceLayoutInput, NonEmptyResources, createDefinedResourceLayout } from "./create-config/create-defined-resource-layout.mjs";
 import { ResourceLayoutShellPublisher } from "./create-config/shell-context.mjs";
 import { LayoutPreviewProps, defineLayoutPreview } from "./create-config/preview.mjs";
@@ -25,8 +30,6 @@ import { InvalidPartContext, InvalidPartError } from "./errors/invalid-part.mjs"
 import { InvalidPartTypeContext, InvalidPartTypeError } from "./errors/invalid-part-type.mjs";
 import { MissingPathVariableContext, MissingPathVariableError } from "./errors/missing-path-variable.mjs";
 import { MissingResourceProviderError } from "./errors/missing-resource-provider.mjs";
-import { LayoutConfigurationError, LayoutConfigurationErrorContext } from "./errors/layout-configuration-error.mjs";
-import { ResourceModuleLoadError, ResourceRenderError, ResourceStateError } from "./errors/resource-state-error.mjs";
 import { AnyComposableComponent, ComposableComponent, ComposableComponentCallable, ComposableComponents, ComposableNameContext, ComposablePresetComponent, ComposablePresetComponentCallProps, ComposablePresetMeta, ComposablePresetProps, ComposableResourceLayout, CreateLayoutComposable, DefinedComposableComponentRecord, LayoutComposablePresetProvider, LayoutComposablesFactory, MakeComposable, MakeComposableOptions, MergePresetProps, PresetPropsFromComposable, RequiredPresetLayoutProps, RequiredPresetRenderProps, ResolveLayoutComposables, collectComposablePresetEntries, createComposableComponent, createLayoutComposableFactory, defineComposableComponent, makeComposable, resolveComposablePresetProps, resolveLayoutComposables } from "@jfdevelops/react-layout-composables";
 import { AnyBuiltPropDefinition, ExtractDefinitionValue, PropError, PropErrorOptions, ResolveLayoutProps, ResolveLayoutPropsAsDefined, ResolveProps, ResolvedBuiltPropShape, createPrimitivePropBuilder, createProp, isPropDefinitionShape, resolvePropDefinitionValues, validateProps } from "@jfdevelops/react-layout-validator";
-export { type AnyBuiltPropDefinition, type AnyComposableComponent, type AnyRenderStateDefinition, type AsStateComposable, type BaseComponent, type BoundDefineResourceLayout, type ComponentTypes, type ComposableComponent, type ComposableComponentCallable, type ComposableComponents, type ComposableNameContext, type ComposablePresetComponent, type ComposablePresetComponentCallProps, type ComposablePresetMeta, type ComposablePresetProps, type ComposableResourceLayout, type ContextualInlineRenderState, type ContextualInlineRenderStates, type CreateDefinedResourceLayoutOptions, type CreateDefinedResourceLayoutResult, type CreateGetComponentForPath, type CreateLayoutBuildingBlocks, type CreateLayoutBuildingBlocksArguments, type CreateLayoutBuildingBlocksResult, type CreateLayoutComposable, type CreateRenderState, type CreateRenderStateBuilderArguments, type CreateRenderStateBuilderResult, type CreateRenderStateFromState, type CreateResourceConfigFn, type CreateResourceConfigForResource, type CreateResourceLayoutWithLayoutOptions, type CreateResourceMap, type CreateResourceMapFn, type CreateViewMapBuiltInRenderStatesOptions, type CreateViewMapFunctionRenderOptions, type CreateViewMapInlineRenderStatesOptions, type CreateViewMapRenderStatesOptions, type CreatedResourceConfig, type DeferredRenderState, type DefineLayoutComposables, type DefineLazyDefaults, type DefineResourceLayoutWithLayoutFn, type DefineResourcesFn, type DefinedComposableComponentRecord, type DefinedResourceLayoutInput, type DefinedResourceLayoutWithShell, type ExtractDefinitionValue, type ForPaths, type ForPathsRenderContext, type GetComponentForPath, type InPropsDefinition, type InPropsFunction, type InPropsObject, type InPropsOptions, type IncludedComponentPropDefinitions, type IncludedPropBehavior, type IncludedProps, type InferredInProps, type InvalidComponentContext, InvalidComponentError, type InvalidConfigContext, InvalidConfigError, type InvalidPartContext, InvalidPartError, type InvalidPartTypeContext, InvalidPartTypeError, type InvalidPathContext, InvalidPathError, type InvalidResourceContext, InvalidResourceError, type InvalidSubResourceContext, InvalidSubResourceError, type IsSubResourceKey, LayoutComposablePresetProvider, type LayoutComposablesDefinition, type LayoutComposablesFactory, LayoutConfigurationError, type LayoutConfigurationErrorContext, type LayoutNameCallback, type LayoutNameContext, type LayoutNameFactory, type LayoutNameInput, type LayoutNameOptions, type LayoutNamePartDefinitions, type LayoutNamePartType, type LayoutNamePartValues, type LayoutNameParts, type LayoutNameResolver, type LayoutPreviewProps, type LayoutRenderProps, type LayoutRenderResourcesAccessor, type LayoutResourceKey, type LayoutResourcesAccessor, type LazyRenderState, type LazyResourceErrorComponent, type LazyResourceLayoutComponent, type LazyResourceLayoutOptions, type LazyResourceLoadingComponent, type LazyResourceStates, type MakeComposable, type MakeComposableOptions, type MergeIntersection, type MergePresetProps, type MergedLayoutInProps, type MissingPathVariableContext, MissingPathVariableError, MissingResourceProviderError, type NonEmptyResources, type NormalizeResource, type NormalizeResources, type NormalizedResourceDefinition, type NormalizedResourceDefinitions, type ParameterizedResourcePath, type PathVariables, type PresetPropsFromComposable, PropError, type PropErrorOptions, type PropsContextRender, type PropsRenderDefinition, ReactLayoutError, type RenderStateCallProps, type RenderStateCallback, type RenderStateComposablesDefinition, type RenderStateContext, type RenderStateFragment, type RenderStateName, type RenderStateOverloads, type RenderStateProps, type RenderStateReferences, type RenderedPathComponent, type RenderedPathComponentHOF, type RequiredPresetLayoutProps, type RequiredPresetRenderProps, type ResolveLayoutComposables, type ResolveLayoutProps, type ResolveLayoutPropsAsDefined, type ResolveProps, type ResolvedBuiltPropShape, type ResolvedIncludedComponentProps, type ResolvedIncludedConfigProps, type ResolvedIncludedProps, type ResolvedIncludedPropsAsDefined, type ResolvedLayoutName, type ResolvedPathValue, type ResourceConfigFragment, type ResourceDefinition, type ResourceDefinitionValue, type ResourceEnum, type ResourceLayoutComponentProps, type ResourceLayoutProvider, type ResourceLayoutProviderProps, type ResourceLayoutShellComponent, type ResourceLayoutShellProps, type ResourceLayoutShellPublisher, ResourceModuleLoadError, type ResourcePath, ResourceRenderError, type ResourceSelection, type ResourceStateError, type ResourceTree, type ShellLayoutDefinition, type ShellRenderContext, type Show, type StateComposable, type StateComposableOptions, type TargetPathBuilder, type TypedBuiltInRenderStates, type TypedInlineRenderState, type TypedRenderStateCallback, type UnionToIntersection, collectComposablePresetEntries, createComposableComponent, createDefinedResourceLayout, createLayoutComposableFactory, createPrimitivePropBuilder, createProp, defineComposableComponent, defineLayoutName, defineLayoutPreview, defineResourceLayout, isPropDefinitionShape, makeComposable, normalizeResource, normalizeResourceDefinitions, normalizeResources, pick, resolveComposablePresetProps, resolveLayoutComposables, resolvePropDefinitionValues, toResourceEnum, validateProps };
+export { type AnyBuiltPropDefinition, type AnyComposableComponent, type AnyRenderStateDefinition, type AsStateComposable, type BaseComponent, type BoundDefineResourceLayout, type ComponentTypes, type ComposableComponent, type ComposableComponentCallable, type ComposableComponents, type ComposableNameContext, type ComposablePresetComponent, type ComposablePresetComponentCallProps, type ComposablePresetMeta, type ComposablePresetProps, type ComposableResourceLayout, type ContextualInlineRenderState, type ContextualInlineRenderStates, type CreateDefinedResourceLayoutOptions, type CreateDefinedResourceLayoutResult, type CreateGetComponentForPath, type CreateLayoutBuildingBlocks, type CreateLayoutBuildingBlocksArguments, type CreateLayoutBuildingBlocksResult, type CreateLayoutComposable, type CreateLazyErrorComponent, type CreateRenderState, type CreateRenderStateBuilderArguments, type CreateRenderStateBuilderResult, type CreateRenderStateFromState, type CreateResourceConfigFn, type CreateResourceConfigForResource, type CreateResourceLayoutWithLayoutOptions, type CreateResourceMap, type CreateResourceMapFn, type CreateViewMapBuiltInRenderStatesOptions, type CreateViewMapFunctionRenderOptions, type CreateViewMapInlineRenderStatesOptions, type CreateViewMapRenderStatesOptions, type CreatedResourceConfig, type DeferredRenderState, type DefineLayoutComposables, type DefineLazyDefaults, type DefineResourceLayoutWithLayoutFn, type DefineResourcesFn, type DefinedComposableComponentRecord, type DefinedResourceLayoutInput, type DefinedResourceLayoutWithShell, type ExtractDefinitionValue, type ForPaths, type ForPathsRenderContext, type GetComponentForPath, type InPropsDefinition, type InPropsFunction, type InPropsObject, type InPropsOptions, type IncludedComponentPropDefinitions, type IncludedPropBehavior, type IncludedProps, type InferredInProps, type InvalidComponentContext, InvalidComponentError, type InvalidConfigContext, InvalidConfigError, type InvalidPartContext, InvalidPartError, type InvalidPartTypeContext, InvalidPartTypeError, type InvalidPathContext, InvalidPathError, type InvalidResourceContext, InvalidResourceError, type InvalidSubResourceContext, InvalidSubResourceError, type IsSubResourceKey, LayoutComposablePresetProvider, type LayoutComposablesDefinition, type LayoutComposablesFactory, LayoutConfigurationError, type LayoutConfigurationErrorContext, type LayoutNameCallback, type LayoutNameContext, type LayoutNameFactory, type LayoutNameInput, type LayoutNameOptions, type LayoutNamePartDefinitions, type LayoutNamePartType, type LayoutNamePartValues, type LayoutNameParts, type LayoutNameResolver, type LayoutPreviewProps, type LayoutRenderProps, type LayoutRenderResourcesAccessor, type LayoutResourceKey, type LayoutResourcesAccessor, type LazyErrorHandlers, type LazyHandle, type LazyOptions, type LazyRenderState, type LazyResourceError, type LazyResourceErrorComponent, type LazyResourceErrorMap, type LazyResourceErrorProps, type LazyResourceLayoutComponent, type LazyResourceLayoutOptions, type LazyResourceLoadingComponent, LazyResourceModuleShapeError, LazyResourceStateNotFoundError, type LazyResourceStates, type LoadStatus, type MakeComposable, type MakeComposableOptions, type MergeIntersection, type MergePresetProps, type MergedLayoutInProps, type MissingPathVariableContext, MissingPathVariableError, MissingResourceProviderError, type NonEmptyResources, type NormalizeResource, type NormalizeResources, type NormalizedResourceDefinition, type NormalizedResourceDefinitions, type ParameterizedResourcePath, type PathVariables, type PresetPropsFromComposable, PropError, type PropErrorOptions, type PropsContextRender, type PropsRenderDefinition, ReactLayoutError, type RenderStateCallProps, type RenderStateCallback, type RenderStateComposablesDefinition, type RenderStateContext, type RenderStateFragment, type RenderStateName, type RenderStateOverloads, type RenderStateProps, type RenderStateReferences, type RenderedPathComponent, type RenderedPathComponentHOF, type RequiredPresetLayoutProps, type RequiredPresetRenderProps, type ResolveLayoutComposables, type ResolveLayoutProps, type ResolveLayoutPropsAsDefined, type ResolveProps, type ResolvedBuiltPropShape, type ResolvedIncludedComponentProps, type ResolvedIncludedConfigProps, type ResolvedIncludedProps, type ResolvedIncludedPropsAsDefined, type ResolvedLayoutName, type ResolvedPathValue, type ResourceConfigFragment, type ResourceDefinition, type ResourceDefinitionValue, type ResourceEnum, type ResourceLayoutComponentProps, type ResourceLayoutProvider, type ResourceLayoutProviderProps, type ResourceLayoutShellComponent, type ResourceLayoutShellProps, type ResourceLayoutShellPublisher, ResourceModuleLoadError, type ResourcePath, ResourceRenderError, type ResourceSelection, type ResourceStateError, type ResourceTree, type ScopedComponentRenderFn, type ShellLayoutDefinition, type ShellRenderContext, type Show, type StateComposable, type StateComposableOptions, type TargetPathBuilder, type TypedBuiltInRenderStates, type TypedInlineRenderState, type TypedRenderStateCallback, type UnionToIntersection, collectComposablePresetEntries, createComposableComponent, createDefinedResourceLayout, createLayoutComposableFactory, createPrimitivePropBuilder, createProp, defineComposableComponent, defineLayoutName, defineLayoutPreview, defineResourceLayout, isLazyResourceError, isPropDefinitionShape, makeComposable, normalizeResource, normalizeResourceDefinitions, normalizeResources, pick, resolveComposablePresetProps, resolveLayoutComposables, resolvePropDefinitionValues, toResourceEnum, validateProps };

package/dist/index.mjs

@@ -1,4 +1,7 @@
 import { ReactLayoutError } from "./errors/react-layout-error.mjs";
+import { LayoutConfigurationError } from "./errors/layout-configuration-error.mjs";
+import { ResourceModuleLoadError, ResourceRenderError } from "./errors/resource-state-error.mjs";
+import { LazyResourceModuleShapeError, LazyResourceStateNotFoundError, isLazyResourceError } from "./errors/lazy-resource-error.mjs";
 import { InvalidConfigError } from "./errors/invalid-config.mjs";
 import { InvalidPathError } from "./errors/invalid-path.mjs";
 import { InvalidResourceError } from "./errors/invalid-resource.mjs";
@@ -8,8 +11,6 @@ import { InvalidPartError } from "./errors/invalid-part.mjs";
 import { InvalidPartTypeError } from "./errors/invalid-part-type.mjs";
 import { MissingPathVariableError } from "./errors/missing-path-variable.mjs";
 import { MissingResourceProviderError } from "./errors/missing-resource-provider.mjs";
-import { LayoutConfigurationError } from "./errors/layout-configuration-error.mjs";
-import { ResourceModuleLoadError, ResourceRenderError } from "./errors/resource-state-error.mjs";
 import { defineLayoutPreview } from "./create-config/preview.mjs";
 import { normalizeResource, normalizeResourceDefinitions, normalizeResources, toResourceEnum } from "./resource.mjs";
 import { pick } from "./utils.mjs";
@@ -19,4 +20,4 @@ import { defineLayoutName } from "./create-config/layout-name.mjs";
 import { LayoutComposablePresetProvider, collectComposablePresetEntries, createComposableComponent, createLayoutComposableFactory, defineComposableComponent, makeComposable, resolveComposablePresetProps, resolveLayoutComposables } from "@jfdevelops/react-layout-composables";
 import { PropError, createPrimitivePropBuilder, createProp, isPropDefinitionShape, resolvePropDefinitionValues, validateProps } from "@jfdevelops/react-layout-validator";
 
-export { InvalidComponentError, InvalidConfigError, InvalidPartError, InvalidPartTypeError, InvalidPathError, InvalidResourceError, InvalidSubResourceError, LayoutComposablePresetProvider, LayoutConfigurationError, MissingPathVariableError, MissingResourceProviderError, PropError, ReactLayoutError, ResourceModuleLoadError, ResourceRenderError, collectComposablePresetEntries, createComposableComponent, createDefinedResourceLayout, createLayoutComposableFactory, createPrimitivePropBuilder, createProp, defineComposableComponent, defineLayoutName, defineLayoutPreview, defineResourceLayout, isPropDefinitionShape, makeComposable, normalizeResource, normalizeResourceDefinitions, normalizeResources, pick, resolveComposablePresetProps, resolveLayoutComposables, resolvePropDefinitionValues, toResourceEnum, validateProps };
+export { InvalidComponentError, InvalidConfigError, InvalidPartError, InvalidPartTypeError, InvalidPathError, InvalidResourceError, InvalidSubResourceError, LayoutComposablePresetProvider, LayoutConfigurationError, LazyResourceModuleShapeError, LazyResourceStateNotFoundError, MissingPathVariableError, MissingResourceProviderError, PropError, ReactLayoutError, ResourceModuleLoadError, ResourceRenderError, collectComposablePresetEntries, createComposableComponent, createDefinedResourceLayout, createLayoutComposableFactory, createPrimitivePropBuilder, createProp, defineComposableComponent, defineLayoutName, defineLayoutPreview, defineResourceLayout, isLazyResourceError, isPropDefinitionShape, makeComposable, normalizeResource, normalizeResourceDefinitions, normalizeResources, pick, resolveComposablePresetProps, resolveLayoutComposables, resolvePropDefinitionValues, toResourceEnum, validateProps };

package/dist/lazy/create-error-component.cjs

@@ -0,0 +1,17 @@
+
+//#region src/lazy/create-error-component.tsx
+/** Function inputs retain their identity; handler maps dispatch by error code. */
+const createLazyErrorComponent = (input) => {
+	if (typeof input === "function") return input;
+	const handlers = input;
+	function LazyResourceErrorByCode(props) {
+		const handler = handlers[props.error.code] ?? handlers.fallback;
+		if (!handler) throw props.error;
+		return handler(props);
+	}
+	return LazyResourceErrorByCode;
+};
+
+//#endregion
+exports.createLazyErrorComponent = createLazyErrorComponent;
+//# sourceMappingURL=create-error-component.cjs.map

package/dist/lazy/create-error-component.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-error-component.cjs","names":[],"sources":["../../src/lazy/create-error-component.tsx"],"sourcesContent":["import type {\n  CreateLazyErrorComponent,\n  LazyErrorHandlers,\n  LazyResourceErrorProps,\n} from './types';\n\n/** Function inputs retain their identity; handler maps dispatch by error code. */\nexport const createLazyErrorComponent: CreateLazyErrorComponent<string> = (\n  input:\n    | ((props: LazyResourceErrorProps) => React.ReactNode)\n    | LazyErrorHandlers<string>,\n) => {\n  if (typeof input === 'function') return input;\n  const handlers = input;\n  function LazyResourceErrorByCode(props: LazyResourceErrorProps) {\n    const handler = handlers[props.error.code] ?? handlers.fallback;\n    if (!handler) throw props.error;\n    return handler(props as never);\n  }\n  return LazyResourceErrorByCode;\n};\n"],"mappings":";;;AAOA,MAAa,4BACX,UAGG;CACH,IAAI,OAAO,UAAU,YAAY,OAAO;CACxC,MAAM,WAAW;CACjB,SAAS,wBAAwB,OAA+B;EAC9D,MAAM,UAAU,SAAS,MAAM,MAAM,SAAS,SAAS;EACvD,IAAI,CAAC,SAAS,MAAM,MAAM;EAC1B,OAAO,QAAQ,KAAc;CAC/B;CACA,OAAO;AACT"}

package/dist/lazy/create-error-component.mjs

@@ -0,0 +1,16 @@
+//#region src/lazy/create-error-component.tsx
+/** Function inputs retain their identity; handler maps dispatch by error code. */
+const createLazyErrorComponent = (input) => {
+	if (typeof input === "function") return input;
+	const handlers = input;
+	function LazyResourceErrorByCode(props) {
+		const handler = handlers[props.error.code] ?? handlers.fallback;
+		if (!handler) throw props.error;
+		return handler(props);
+	}
+	return LazyResourceErrorByCode;
+};
+
+//#endregion
+export { createLazyErrorComponent };
+//# sourceMappingURL=create-error-component.mjs.map

package/dist/lazy/create-error-component.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-error-component.mjs","names":[],"sources":["../../src/lazy/create-error-component.tsx"],"sourcesContent":["import type {\n  CreateLazyErrorComponent,\n  LazyErrorHandlers,\n  LazyResourceErrorProps,\n} from './types';\n\n/** Function inputs retain their identity; handler maps dispatch by error code. */\nexport const createLazyErrorComponent: CreateLazyErrorComponent<string> = (\n  input:\n    | ((props: LazyResourceErrorProps) => React.ReactNode)\n    | LazyErrorHandlers<string>,\n) => {\n  if (typeof input === 'function') return input;\n  const handlers = input;\n  function LazyResourceErrorByCode(props: LazyResourceErrorProps) {\n    const handler = handlers[props.error.code] ?? handlers.fallback;\n    if (!handler) throw props.error;\n    return handler(props as never);\n  }\n  return LazyResourceErrorByCode;\n};\n"],"mappings":";;AAOA,MAAa,4BACX,UAGG;CACH,IAAI,OAAO,UAAU,YAAY,OAAO;CACxC,MAAM,WAAW;CACjB,SAAS,wBAAwB,OAA+B;EAC9D,MAAM,UAAU,SAAS,MAAM,MAAM,SAAS,SAAS;EACvD,IAAI,CAAC,SAAS,MAAM,MAAM;EAC1B,OAAO,QAAQ,KAAc;CAC/B;CACA,OAAO;AACT"}

package/dist/lazy/create-lazy-loader.cjs

@@ -0,0 +1,78 @@
+const require_resource_state_error = require('../errors/resource-state-error.cjs');
+const require_lazy_resource_error = require('../errors/lazy-resource-error.cjs');
+let react = require("react");
+
+//#region src/lazy/create-lazy-loader.ts
+/** A single import cache and lifecycle shared by every lazy entry point. */
+function createLazyLoader(options) {
+	let promise;
+	let preloadPromise;
+	let status = "unresolved";
+	const components = /* @__PURE__ */ new Map();
+	let generation = 0;
+	function get() {
+		if (promise) return promise;
+		const attempt = generation;
+		status = "loading";
+		options.hooks?.onLoadStart?.();
+		promise = Promise.resolve().then(options.load).catch((cause) => {
+			if (require_lazy_resource_error.isLazyResourceError(cause)) throw cause;
+			if (process.env.NODE_ENV !== "production") console.error(`[react-layout] lazy "${options.label}" failed to load`, cause);
+			throw new require_resource_state_error.ResourceModuleLoadError(options.label, cause);
+		}).then(options.select).then((selected) => {
+			if (attempt === generation) {
+				status = "resolved";
+				options.hooks?.onLoadSuccess?.();
+			}
+			return selected;
+		}, (error) => {
+			if (attempt === generation) {
+				status = "error";
+				options.hooks?.onLoadError?.(error);
+			}
+			throw error;
+		});
+		return promise;
+	}
+	return {
+		get,
+		get status() {
+			return status;
+		},
+		preload: () => preloadPromise ??= get().then(() => void 0),
+		reset() {
+			generation++;
+			promise = void 0;
+			preloadPromise = void 0;
+			components.clear();
+			status = "unresolved";
+		},
+		component(member, map) {
+			const key = map ?? member;
+			let component = components.get(key);
+			if (!component) {
+				component = (0, react.lazy)(async () => {
+					const attempt = generation;
+					const selected = await get();
+					try {
+						const candidate = map ? map(selected) : member === void 0 ? selected : selected[member];
+						if (typeof candidate !== "function") throw new require_lazy_resource_error.LazyResourceStateNotFoundError(options.label, String(member));
+						return { default: candidate };
+					} catch (error) {
+						if (attempt === generation && require_lazy_resource_error.isLazyResourceError(error)) {
+							status = "error";
+							options.hooks?.onLoadError?.(error);
+						}
+						throw error;
+					}
+				});
+				components.set(key, component);
+			}
+			return component;
+		}
+	};
+}
+
+//#endregion
+exports.createLazyLoader = createLazyLoader;
+//# sourceMappingURL=create-lazy-loader.cjs.map

package/dist/lazy/create-lazy-loader.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-lazy-loader.cjs","names":["isLazyResourceError","ResourceModuleLoadError","LazyResourceStateNotFoundError"],"sources":["../../src/lazy/create-lazy-loader.ts"],"sourcesContent":["import { lazy, type ComponentType } from 'react';\nimport { ResourceModuleLoadError } from '../errors/resource-state-error';\nimport {\n  LazyResourceStateNotFoundError,\n  isLazyResourceError,\n  type LazyResourceError,\n} from '../errors/lazy-resource-error';\nimport type { LazyHandle, LoadStatus } from './types';\n\nexport type LazyResourceLoadHooks = {\n  onLoadStart?: () => void;\n  onLoadSuccess?: () => void;\n  onLoadError?: (error: LazyResourceError) => void;\n  onMount?: () => (() => void) | undefined;\n};\n\nexport type LazyLoader<Selected> = LazyHandle & {\n  get(): Promise<Selected>;\n  reset(): void;\n  component(\n    member?: PropertyKey,\n    map?: (selected: Selected) => ComponentType<any>,\n  ): ComponentType<any>;\n};\n\n/** A single import cache and lifecycle shared by every lazy entry point. */\nexport function createLazyLoader<Module, Selected>(options: {\n  load: () => Promise<Module>;\n  select: (module: Module) => Selected | Promise<Selected>;\n  label: string;\n  hooks?: LazyResourceLoadHooks;\n}): LazyLoader<Selected> {\n  let promise: Promise<Selected> | undefined;\n  let preloadPromise: Promise<void> | undefined;\n  let status: LoadStatus = 'unresolved';\n  const components = new Map<unknown, ComponentType<any>>();\n  let generation = 0;\n\n  function get() {\n    if (promise) return promise;\n    const attempt = generation;\n    status = 'loading';\n    options.hooks?.onLoadStart?.();\n    promise = Promise.resolve()\n      .then(options.load)\n      .catch((cause: unknown) => {\n        if (isLazyResourceError(cause)) throw cause;\n        if (process.env.NODE_ENV !== 'production') {\n          console.error(\n            `[react-layout] lazy \"${options.label}\" failed to load`,\n            cause,\n          );\n        }\n        throw new ResourceModuleLoadError(options.label, cause);\n      })\n      .then(options.select)\n      .then(\n        (selected) => {\n          if (attempt === generation) {\n            status = 'resolved';\n            options.hooks?.onLoadSuccess?.();\n          }\n          return selected;\n        },\n        (error: LazyResourceError) => {\n          if (attempt === generation) {\n            status = 'error';\n            options.hooks?.onLoadError?.(error);\n          }\n          throw error;\n        },\n      );\n    return promise;\n  }\n\n  return {\n    get,\n    get status() {\n      return status;\n    },\n    preload: () => (preloadPromise ??= get().then(() => undefined)),\n    reset() {\n      generation++;\n      promise = undefined;\n      preloadPromise = undefined;\n      components.clear();\n      status = 'unresolved';\n    },\n    component(member, map) {\n      const key = map ?? member;\n      let component = components.get(key);\n      if (!component) {\n        component = lazy(async () => {\n          const attempt = generation;\n          const selected = await get();\n          try {\n            const candidate = map\n              ? map(selected)\n              : member === undefined\n                ? selected\n                : (selected as Record<PropertyKey, unknown>)[member];\n            if (typeof candidate !== 'function') {\n              throw new LazyResourceStateNotFoundError(\n                options.label,\n                String(member),\n              );\n            }\n            return { default: candidate as ComponentType<any> };\n          } catch (error) {\n            if (attempt === generation && isLazyResourceError(error)) {\n              status = 'error';\n              options.hooks?.onLoadError?.(error);\n            }\n            throw error;\n          }\n        });\n        components.set(key, component);\n      }\n      return component;\n    },\n  };\n}\n"],"mappings":";;;;;;AA0BA,SAAgB,iBAAmC,SAK1B;CACvB,IAAI;CACJ,IAAI;CACJ,IAAI,SAAqB;CACzB,MAAM,6BAAa,IAAI,IAAiC;CACxD,IAAI,aAAa;CAEjB,SAAS,MAAM;EACb,IAAI,SAAS,OAAO;EACpB,MAAM,UAAU;EAChB,SAAS;EACT,QAAQ,OAAO,cAAc;EAC7B,UAAU,QAAQ,QAAQ,EACvB,KAAK,QAAQ,IAAI,EACjB,OAAO,UAAmB;GACzB,IAAIA,gDAAoB,KAAK,GAAG,MAAM;GACtC,IAAI,QAAQ,IAAI,aAAa,cAC3B,QAAQ,MACN,wBAAwB,QAAQ,MAAM,mBACtC,KACF;GAEF,MAAM,IAAIC,qDAAwB,QAAQ,OAAO,KAAK;EACxD,CAAC,EACA,KAAK,QAAQ,MAAM,EACnB,MACE,aAAa;GACZ,IAAI,YAAY,YAAY;IAC1B,SAAS;IACT,QAAQ,OAAO,gBAAgB;GACjC;GACA,OAAO;EACT,IACC,UAA6B;GAC5B,IAAI,YAAY,YAAY;IAC1B,SAAS;IACT,QAAQ,OAAO,cAAc,KAAK;GACpC;GACA,MAAM;EACR,CACF;EACF,OAAO;CACT;CAEA,OAAO;EACL;EACA,IAAI,SAAS;GACX,OAAO;EACT;EACA,eAAgB,mBAAmB,IAAI,EAAE,WAAW,MAAS;EAC7D,QAAQ;GACN;GACA,UAAU;GACV,iBAAiB;GACjB,WAAW,MAAM;GACjB,SAAS;EACX;EACA,UAAU,QAAQ,KAAK;GACrB,MAAM,MAAM,OAAO;GACnB,IAAI,YAAY,WAAW,IAAI,GAAG;GAClC,IAAI,CAAC,WAAW;IACd,4BAAiB,YAAY;KAC3B,MAAM,UAAU;KAChB,MAAM,WAAW,MAAM,IAAI;KAC3B,IAAI;MACF,MAAM,YAAY,MACd,IAAI,QAAQ,IACZ,WAAW,SACT,WACC,SAA0C;MACjD,IAAI,OAAO,cAAc,YACvB,MAAM,IAAIC,2DACR,QAAQ,OACR,OAAO,MAAM,CACf;MAEF,OAAO,EAAE,SAAS,UAAgC;KACpD,SAAS,OAAO;MACd,IAAI,YAAY,cAAcF,gDAAoB,KAAK,GAAG;OACxD,SAAS;OACT,QAAQ,OAAO,cAAc,KAAK;MACpC;MACA,MAAM;KACR;IACF,CAAC;IACD,WAAW,IAAI,KAAK,SAAS;GAC/B;GACA,OAAO;EACT;CACF;AACF"}

package/dist/lazy/create-lazy-loader.d.cts

@@ -0,0 +1,19 @@
+import { LazyResourceError } from "../errors/lazy-resource-error.cjs";
+import { LazyHandle } from "./types.cjs";
+import { ComponentType } from "react";
+
+//#region src/lazy/create-lazy-loader.d.ts
+type LazyResourceLoadHooks = {
+  onLoadStart?: () => void;
+  onLoadSuccess?: () => void;
+  onLoadError?: (error: LazyResourceError) => void;
+  onMount?: () => (() => void) | undefined;
+};
+type LazyLoader<Selected> = LazyHandle & {
+  get(): Promise<Selected>;
+  reset(): void;
+  component(member?: PropertyKey, map?: (selected: Selected) => ComponentType<any>): ComponentType<any>;
+};
+//#endregion
+export { LazyLoader, LazyResourceLoadHooks };
+//# sourceMappingURL=create-lazy-loader.d.cts.map

package/dist/lazy/create-lazy-loader.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-lazy-loader.d.cts","names":[],"sources":["../../src/lazy/create-lazy-loader.ts"],"mappings":";;;;;KASY,qBAAA;EACV,WAAA;EACA,aAAA;EACA,WAAA,IAAe,KAAA,EAAO,iBAAiB;EACvC,OAAA;AAAA;AAAA,KAGU,UAAA,aAAuB,UAAA;EACjC,GAAA,IAAO,OAAA,CAAQ,QAAA;EACf,KAAA;EACA,SAAA,CACE,MAAA,GAAS,WAAA,EACT,GAAA,IAAO,QAAA,EAAU,QAAA,KAAa,aAAA,QAC7B,aAAA;AAAA"}

package/dist/lazy/create-lazy-loader.d.mts

@@ -0,0 +1,19 @@
+import { LazyResourceError } from "../errors/lazy-resource-error.mjs";
+import { LazyHandle } from "./types.mjs";
+import { ComponentType } from "react";
+
+//#region src/lazy/create-lazy-loader.d.ts
+type LazyResourceLoadHooks = {
+  onLoadStart?: () => void;
+  onLoadSuccess?: () => void;
+  onLoadError?: (error: LazyResourceError) => void;
+  onMount?: () => (() => void) | undefined;
+};
+type LazyLoader<Selected> = LazyHandle & {
+  get(): Promise<Selected>;
+  reset(): void;
+  component(member?: PropertyKey, map?: (selected: Selected) => ComponentType<any>): ComponentType<any>;
+};
+//#endregion
+export { LazyLoader, LazyResourceLoadHooks };
+//# sourceMappingURL=create-lazy-loader.d.mts.map

package/dist/lazy/create-lazy-loader.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-lazy-loader.d.mts","names":[],"sources":["../../src/lazy/create-lazy-loader.ts"],"mappings":";;;;;KASY,qBAAA;EACV,WAAA;EACA,aAAA;EACA,WAAA,IAAe,KAAA,EAAO,iBAAiB;EACvC,OAAA;AAAA;AAAA,KAGU,UAAA,aAAuB,UAAA;EACjC,GAAA,IAAO,OAAA,CAAQ,QAAA;EACf,KAAA;EACA,SAAA,CACE,MAAA,GAAS,WAAA,EACT,GAAA,IAAO,QAAA,EAAU,QAAA,KAAa,aAAA,QAC7B,aAAA;AAAA"}

package/dist/lazy/create-lazy-loader.mjs

@@ -0,0 +1,78 @@
+import { ResourceModuleLoadError } from "../errors/resource-state-error.mjs";
+import { LazyResourceStateNotFoundError, isLazyResourceError } from "../errors/lazy-resource-error.mjs";
+import { lazy } from "react";
+
+//#region src/lazy/create-lazy-loader.ts
+/** A single import cache and lifecycle shared by every lazy entry point. */
+function createLazyLoader(options) {
+	let promise;
+	let preloadPromise;
+	let status = "unresolved";
+	const components = /* @__PURE__ */ new Map();
+	let generation = 0;
+	function get() {
+		if (promise) return promise;
+		const attempt = generation;
+		status = "loading";
+		options.hooks?.onLoadStart?.();
+		promise = Promise.resolve().then(options.load).catch((cause) => {
+			if (isLazyResourceError(cause)) throw cause;
+			if (process.env.NODE_ENV !== "production") console.error(`[react-layout] lazy "${options.label}" failed to load`, cause);
+			throw new ResourceModuleLoadError(options.label, cause);
+		}).then(options.select).then((selected) => {
+			if (attempt === generation) {
+				status = "resolved";
+				options.hooks?.onLoadSuccess?.();
+			}
+			return selected;
+		}, (error) => {
+			if (attempt === generation) {
+				status = "error";
+				options.hooks?.onLoadError?.(error);
+			}
+			throw error;
+		});
+		return promise;
+	}
+	return {
+		get,
+		get status() {
+			return status;
+		},
+		preload: () => preloadPromise ??= get().then(() => void 0),
+		reset() {
+			generation++;
+			promise = void 0;
+			preloadPromise = void 0;
+			components.clear();
+			status = "unresolved";
+		},
+		component(member, map) {
+			const key = map ?? member;
+			let component = components.get(key);
+			if (!component) {
+				component = lazy(async () => {
+					const attempt = generation;
+					const selected = await get();
+					try {
+						const candidate = map ? map(selected) : member === void 0 ? selected : selected[member];
+						if (typeof candidate !== "function") throw new LazyResourceStateNotFoundError(options.label, String(member));
+						return { default: candidate };
+					} catch (error) {
+						if (attempt === generation && isLazyResourceError(error)) {
+							status = "error";
+							options.hooks?.onLoadError?.(error);
+						}
+						throw error;
+					}
+				});
+				components.set(key, component);
+			}
+			return component;
+		}
+	};
+}
+
+//#endregion
+export { createLazyLoader };
+//# sourceMappingURL=create-lazy-loader.mjs.map

package/dist/lazy/create-lazy-loader.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-lazy-loader.mjs","names":[],"sources":["../../src/lazy/create-lazy-loader.ts"],"sourcesContent":["import { lazy, type ComponentType } from 'react';\nimport { ResourceModuleLoadError } from '../errors/resource-state-error';\nimport {\n  LazyResourceStateNotFoundError,\n  isLazyResourceError,\n  type LazyResourceError,\n} from '../errors/lazy-resource-error';\nimport type { LazyHandle, LoadStatus } from './types';\n\nexport type LazyResourceLoadHooks = {\n  onLoadStart?: () => void;\n  onLoadSuccess?: () => void;\n  onLoadError?: (error: LazyResourceError) => void;\n  onMount?: () => (() => void) | undefined;\n};\n\nexport type LazyLoader<Selected> = LazyHandle & {\n  get(): Promise<Selected>;\n  reset(): void;\n  component(\n    member?: PropertyKey,\n    map?: (selected: Selected) => ComponentType<any>,\n  ): ComponentType<any>;\n};\n\n/** A single import cache and lifecycle shared by every lazy entry point. */\nexport function createLazyLoader<Module, Selected>(options: {\n  load: () => Promise<Module>;\n  select: (module: Module) => Selected | Promise<Selected>;\n  label: string;\n  hooks?: LazyResourceLoadHooks;\n}): LazyLoader<Selected> {\n  let promise: Promise<Selected> | undefined;\n  let preloadPromise: Promise<void> | undefined;\n  let status: LoadStatus = 'unresolved';\n  const components = new Map<unknown, ComponentType<any>>();\n  let generation = 0;\n\n  function get() {\n    if (promise) return promise;\n    const attempt = generation;\n    status = 'loading';\n    options.hooks?.onLoadStart?.();\n    promise = Promise.resolve()\n      .then(options.load)\n      .catch((cause: unknown) => {\n        if (isLazyResourceError(cause)) throw cause;\n        if (process.env.NODE_ENV !== 'production') {\n          console.error(\n            `[react-layout] lazy \"${options.label}\" failed to load`,\n            cause,\n          );\n        }\n        throw new ResourceModuleLoadError(options.label, cause);\n      })\n      .then(options.select)\n      .then(\n        (selected) => {\n          if (attempt === generation) {\n            status = 'resolved';\n            options.hooks?.onLoadSuccess?.();\n          }\n          return selected;\n        },\n        (error: LazyResourceError) => {\n          if (attempt === generation) {\n            status = 'error';\n            options.hooks?.onLoadError?.(error);\n          }\n          throw error;\n        },\n      );\n    return promise;\n  }\n\n  return {\n    get,\n    get status() {\n      return status;\n    },\n    preload: () => (preloadPromise ??= get().then(() => undefined)),\n    reset() {\n      generation++;\n      promise = undefined;\n      preloadPromise = undefined;\n      components.clear();\n      status = 'unresolved';\n    },\n    component(member, map) {\n      const key = map ?? member;\n      let component = components.get(key);\n      if (!component) {\n        component = lazy(async () => {\n          const attempt = generation;\n          const selected = await get();\n          try {\n            const candidate = map\n              ? map(selected)\n              : member === undefined\n                ? selected\n                : (selected as Record<PropertyKey, unknown>)[member];\n            if (typeof candidate !== 'function') {\n              throw new LazyResourceStateNotFoundError(\n                options.label,\n                String(member),\n              );\n            }\n            return { default: candidate as ComponentType<any> };\n          } catch (error) {\n            if (attempt === generation && isLazyResourceError(error)) {\n              status = 'error';\n              options.hooks?.onLoadError?.(error);\n            }\n            throw error;\n          }\n        });\n        components.set(key, component);\n      }\n      return component;\n    },\n  };\n}\n"],"mappings":";;;;;;AA0BA,SAAgB,iBAAmC,SAK1B;CACvB,IAAI;CACJ,IAAI;CACJ,IAAI,SAAqB;CACzB,MAAM,6BAAa,IAAI,IAAiC;CACxD,IAAI,aAAa;CAEjB,SAAS,MAAM;EACb,IAAI,SAAS,OAAO;EACpB,MAAM,UAAU;EAChB,SAAS;EACT,QAAQ,OAAO,cAAc;EAC7B,UAAU,QAAQ,QAAQ,EACvB,KAAK,QAAQ,IAAI,EACjB,OAAO,UAAmB;GACzB,IAAI,oBAAoB,KAAK,GAAG,MAAM;GACtC,IAAI,QAAQ,IAAI,aAAa,cAC3B,QAAQ,MACN,wBAAwB,QAAQ,MAAM,mBACtC,KACF;GAEF,MAAM,IAAI,wBAAwB,QAAQ,OAAO,KAAK;EACxD,CAAC,EACA,KAAK,QAAQ,MAAM,EACnB,MACE,aAAa;GACZ,IAAI,YAAY,YAAY;IAC1B,SAAS;IACT,QAAQ,OAAO,gBAAgB;GACjC;GACA,OAAO;EACT,IACC,UAA6B;GAC5B,IAAI,YAAY,YAAY;IAC1B,SAAS;IACT,QAAQ,OAAO,cAAc,KAAK;GACpC;GACA,MAAM;EACR,CACF;EACF,OAAO;CACT;CAEA,OAAO;EACL;EACA,IAAI,SAAS;GACX,OAAO;EACT;EACA,eAAgB,mBAAmB,IAAI,EAAE,WAAW,MAAS;EAC7D,QAAQ;GACN;GACA,UAAU;GACV,iBAAiB;GACjB,WAAW,MAAM;GACjB,SAAS;EACX;EACA,UAAU,QAAQ,KAAK;GACrB,MAAM,MAAM,OAAO;GACnB,IAAI,YAAY,WAAW,IAAI,GAAG;GAClC,IAAI,CAAC,WAAW;IACd,YAAY,KAAK,YAAY;KAC3B,MAAM,UAAU;KAChB,MAAM,WAAW,MAAM,IAAI;KAC3B,IAAI;MACF,MAAM,YAAY,MACd,IAAI,QAAQ,IACZ,WAAW,SACT,WACC,SAA0C;MACjD,IAAI,OAAO,cAAc,YACvB,MAAM,IAAI,+BACR,QAAQ,OACR,OAAO,MAAM,CACf;MAEF,OAAO,EAAE,SAAS,UAAgC;KACpD,SAAS,OAAO;MACd,IAAI,YAAY,cAAc,oBAAoB,KAAK,GAAG;OACxD,SAAS;OACT,QAAQ,OAAO,cAAc,KAAK;MACpC;MACA,MAAM;KACR;IACF,CAAC;IACD,WAAW,IAAI,KAAK,SAAS;GAC/B;GACA,OAAO;EACT;CACF;AACF"}

package/dist/lazy/fallback-props.cjs

@@ -0,0 +1,9 @@
+let react = require("react");
+
+//#region src/lazy/fallback-props.ts
+/** Scoped fallbacks receive current caller options without rebuilding their layout. */
+const LazyFallbackPropsContext = (0, react.createContext)(void 0);
+
+//#endregion
+exports.LazyFallbackPropsContext = LazyFallbackPropsContext;
+//# sourceMappingURL=fallback-props.cjs.map

package/dist/lazy/fallback-props.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback-props.cjs","names":[],"sources":["../../src/lazy/fallback-props.ts"],"sourcesContent":["import { createContext } from 'react';\n\n/** Scoped fallbacks receive current caller options without rebuilding their layout. */\nexport const LazyFallbackPropsContext = createContext<\n  { owner?: string; props: Record<string, unknown> } | undefined\n>(undefined);\n"],"mappings":";;;;AAGA,MAAa,oDAEX,MAAS"}

package/dist/lazy/fallback-props.mjs

@@ -0,0 +1,9 @@
+import { createContext } from "react";
+
+//#region src/lazy/fallback-props.ts
+/** Scoped fallbacks receive current caller options without rebuilding their layout. */
+const LazyFallbackPropsContext = createContext(void 0);
+
+//#endregion
+export { LazyFallbackPropsContext };
+//# sourceMappingURL=fallback-props.mjs.map

package/dist/lazy/fallback-props.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback-props.mjs","names":[],"sources":["../../src/lazy/fallback-props.ts"],"sourcesContent":["import { createContext } from 'react';\n\n/** Scoped fallbacks receive current caller options without rebuilding their layout. */\nexport const LazyFallbackPropsContext = createContext<\n  { owner?: string; props: Record<string, unknown> } | undefined\n>(undefined);\n"],"mappings":";;;;AAGA,MAAa,2BAA2B,cAEtC,MAAS"}

package/dist/lazy/inspection.cjs

@@ -0,0 +1,51 @@
+let _jfdevelops_react_layout_devtools_core = require("@jfdevelops/react-layout-devtools-core");
+
+//#region src/lazy/inspection.ts
+/** Register a declaration before its import runs, retaining one node on retry. */
+function inspectLazy(label, store = (0, _jfdevelops_react_layout_devtools_core.createInspectionStore)(), parent) {
+	const id = (0, _jfdevelops_react_layout_devtools_core.inspectionId)("lazy");
+	function update(status, error) {
+		store.node({
+			id,
+			kind: "lazy",
+			label,
+			status,
+			unresolved: status !== "resolved",
+			error: error && (0, _jfdevelops_react_layout_devtools_core.serializeInspectionError)(error)
+		});
+	}
+	update("unresolved");
+	if (parent) store.edge(parent, id, "declares");
+	return {
+		id,
+		store,
+		hooks: {
+			onLoadStart: () => update("loading"),
+			onLoadSuccess: () => update("resolved"),
+			onLoadError: (error) => update("error", error),
+			onMount: () => store.mount(id)
+		},
+		setLabel(value) {
+			label = value;
+			update("unresolved");
+		}
+	};
+}
+function withLazyHandle(target, handle) {
+	Object.defineProperties(target, {
+		preload: {
+			value: handle.preload,
+			enumerable: false
+		},
+		status: {
+			get: () => handle.status,
+			enumerable: false
+		}
+	});
+	return target;
+}
+
+//#endregion
+exports.inspectLazy = inspectLazy;
+exports.withLazyHandle = withLazyHandle;
+//# sourceMappingURL=inspection.cjs.map

package/dist/lazy/inspection.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspection.cjs","names":[],"sources":["../../src/lazy/inspection.ts"],"sourcesContent":["import {\n  createInspectionStore,\n  inspectionId,\n  serializeInspectionError,\n  type InspectionStore,\n  type LoadStatus,\n} from '@jfdevelops/react-layout-devtools-core';\nimport type { LazyResourceLoadHooks } from './create-lazy-loader';\nimport type { LazyResourceError } from '../errors/lazy-resource-error';\n\n/** Register a declaration before its import runs, retaining one node on retry. */\nexport function inspectLazy(\n  label: string,\n  store: InspectionStore = createInspectionStore(),\n  parent?: string,\n) {\n  const id = inspectionId('lazy');\n  function update(status: LoadStatus, error?: LazyResourceError) {\n    store.node({\n      id,\n      kind: 'lazy',\n      label,\n      status,\n      unresolved: status !== 'resolved',\n      error: error && serializeInspectionError(error),\n    });\n  }\n  update('unresolved');\n  if (parent) store.edge(parent, id, 'declares');\n  const hooks: LazyResourceLoadHooks = {\n    onLoadStart: () => update('loading'),\n    onLoadSuccess: () => update('resolved'),\n    onLoadError: (error) => update('error', error),\n    onMount: () => store.mount(id),\n  };\n  return {\n    id,\n    store,\n    hooks,\n    setLabel(value: string) {\n      label = value;\n      update('unresolved');\n    },\n  };\n}\n\nexport function withLazyHandle<T extends object>(\n  target: T,\n  handle: import('./types').LazyHandle,\n): T & import('./types').LazyHandle {\n  Object.defineProperties(target, {\n    preload: { value: handle.preload, enumerable: false },\n    status: { get: () => handle.status, enumerable: false },\n  });\n  return target as T & import('./types').LazyHandle;\n}\n"],"mappings":";;;;AAWA,SAAgB,YACd,OACA,0EAA+C,GAC/C,QACA;CACA,MAAM,8DAAkB,MAAM;CAC9B,SAAS,OAAO,QAAoB,OAA2B;EAC7D,MAAM,KAAK;GACT;GACA,MAAM;GACN;GACA;GACA,YAAY,WAAW;GACvB,OAAO,8EAAkC,KAAK;EAChD,CAAC;CACH;CACA,OAAO,YAAY;CACnB,IAAI,QAAQ,MAAM,KAAK,QAAQ,IAAI,UAAU;CAO7C,OAAO;EACL;EACA;EACA;GARA,mBAAmB,OAAO,SAAS;GACnC,qBAAqB,OAAO,UAAU;GACtC,cAAc,UAAU,OAAO,SAAS,KAAK;GAC7C,eAAe,MAAM,MAAM,EAAE;EAKzB;EACJ,SAAS,OAAe;GACtB,QAAQ;GACR,OAAO,YAAY;EACrB;CACF;AACF;AAEA,SAAgB,eACd,QACA,QACkC;CAClC,OAAO,iBAAiB,QAAQ;EAC9B,SAAS;GAAE,OAAO,OAAO;GAAS,YAAY;EAAM;EACpD,QAAQ;GAAE,WAAW,OAAO;GAAQ,YAAY;EAAM;CACxD,CAAC;CACD,OAAO;AACT"}

package/dist/lazy/inspection.d.cts

@@ -0,0 +1,28 @@
+import { LazyResourceLoadHooks } from "./create-lazy-loader.cjs";
+import { InspectionStore } from "@jfdevelops/react-layout-devtools-core";
+
+//#region src/lazy/inspection.d.ts
+/** Register a declaration before its import runs, retaining one node on retry. */
+declare function inspectLazy(label: string, store?: InspectionStore, parent?: string): {
+  id: string;
+  store: {
+    getSnapshot(): import("@jfdevelops/react-layout-devtools-core").GraphSnapshot;
+    subscribe(listener: () => void): () => void;
+    registerPreview(instance: import("@jfdevelops/react-layout-devtools-core").PreviewInstance, controller: import("@jfdevelops/react-layout-devtools-core").PreviewController): () => void;
+    preview(instanceId: string, state?: string): void;
+    previewError(instanceId: string, error: string): void;
+    connectPreview(): () => void;
+    node(node: Omit<import("@jfdevelops/react-layout-devtools-core").GraphNode, "active"> & {
+      active?: number;
+    }): string;
+    edge(source: string, target: string, relationship: import("@jfdevelops/react-layout-devtools-core").GraphEdge["relationship"]): void;
+    mount(...ids: string[]): () => void;
+    connect(value: object): void;
+    attach<T extends object>(value: T): T;
+  };
+  hooks: LazyResourceLoadHooks;
+  setLabel(value: string): void;
+};
+//#endregion
+export { inspectLazy };
+//# sourceMappingURL=inspection.d.cts.map

package/dist/lazy/inspection.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspection.d.cts","names":[],"sources":["../../src/lazy/inspection.ts"],"mappings":";;;;;iBAWgB,WAAA,CACd,KAAA,UACA,KAAA,GAAO,eAAA,EACP,MAAA"}

package/dist/lazy/inspection.d.mts

@@ -0,0 +1,28 @@
+import { LazyResourceLoadHooks } from "./create-lazy-loader.mjs";
+import { InspectionStore } from "@jfdevelops/react-layout-devtools-core";
+
+//#region src/lazy/inspection.d.ts
+/** Register a declaration before its import runs, retaining one node on retry. */
+declare function inspectLazy(label: string, store?: InspectionStore, parent?: string): {
+  id: string;
+  store: {
+    getSnapshot(): import("@jfdevelops/react-layout-devtools-core").GraphSnapshot;
+    subscribe(listener: () => void): () => void;
+    registerPreview(instance: import("@jfdevelops/react-layout-devtools-core").PreviewInstance, controller: import("@jfdevelops/react-layout-devtools-core").PreviewController): () => void;
+    preview(instanceId: string, state?: string): void;
+    previewError(instanceId: string, error: string): void;
+    connectPreview(): () => void;
+    node(node: Omit<import("@jfdevelops/react-layout-devtools-core").GraphNode, "active"> & {
+      active?: number;
+    }): string;
+    edge(source: string, target: string, relationship: import("@jfdevelops/react-layout-devtools-core").GraphEdge["relationship"]): void;
+    mount(...ids: string[]): () => void;
+    connect(value: object): void;
+    attach<T extends object>(value: T): T;
+  };
+  hooks: LazyResourceLoadHooks;
+  setLabel(value: string): void;
+};
+//#endregion
+export { inspectLazy };
+//# sourceMappingURL=inspection.d.mts.map

package/dist/lazy/inspection.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspection.d.mts","names":[],"sources":["../../src/lazy/inspection.ts"],"mappings":";;;;;iBAWgB,WAAA,CACd,KAAA,UACA,KAAA,GAAO,eAAA,EACP,MAAA"}

package/dist/lazy/inspection.mjs

@@ -0,0 +1,50 @@
+import { createInspectionStore, inspectionId, serializeInspectionError } from "@jfdevelops/react-layout-devtools-core";
+
+//#region src/lazy/inspection.ts
+/** Register a declaration before its import runs, retaining one node on retry. */
+function inspectLazy(label, store = createInspectionStore(), parent) {
+	const id = inspectionId("lazy");
+	function update(status, error) {
+		store.node({
+			id,
+			kind: "lazy",
+			label,
+			status,
+			unresolved: status !== "resolved",
+			error: error && serializeInspectionError(error)
+		});
+	}
+	update("unresolved");
+	if (parent) store.edge(parent, id, "declares");
+	return {
+		id,
+		store,
+		hooks: {
+			onLoadStart: () => update("loading"),
+			onLoadSuccess: () => update("resolved"),
+			onLoadError: (error) => update("error", error),
+			onMount: () => store.mount(id)
+		},
+		setLabel(value) {
+			label = value;
+			update("unresolved");
+		}
+	};
+}
+function withLazyHandle(target, handle) {
+	Object.defineProperties(target, {
+		preload: {
+			value: handle.preload,
+			enumerable: false
+		},
+		status: {
+			get: () => handle.status,
+			enumerable: false
+		}
+	});
+	return target;
+}
+
+//#endregion
+export { inspectLazy, withLazyHandle };
+//# sourceMappingURL=inspection.mjs.map

package/dist/lazy/inspection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspection.mjs","names":[],"sources":["../../src/lazy/inspection.ts"],"sourcesContent":["import {\n  createInspectionStore,\n  inspectionId,\n  serializeInspectionError,\n  type InspectionStore,\n  type LoadStatus,\n} from '@jfdevelops/react-layout-devtools-core';\nimport type { LazyResourceLoadHooks } from './create-lazy-loader';\nimport type { LazyResourceError } from '../errors/lazy-resource-error';\n\n/** Register a declaration before its import runs, retaining one node on retry. */\nexport function inspectLazy(\n  label: string,\n  store: InspectionStore = createInspectionStore(),\n  parent?: string,\n) {\n  const id = inspectionId('lazy');\n  function update(status: LoadStatus, error?: LazyResourceError) {\n    store.node({\n      id,\n      kind: 'lazy',\n      label,\n      status,\n      unresolved: status !== 'resolved',\n      error: error && serializeInspectionError(error),\n    });\n  }\n  update('unresolved');\n  if (parent) store.edge(parent, id, 'declares');\n  const hooks: LazyResourceLoadHooks = {\n    onLoadStart: () => update('loading'),\n    onLoadSuccess: () => update('resolved'),\n    onLoadError: (error) => update('error', error),\n    onMount: () => store.mount(id),\n  };\n  return {\n    id,\n    store,\n    hooks,\n    setLabel(value: string) {\n      label = value;\n      update('unresolved');\n    },\n  };\n}\n\nexport function withLazyHandle<T extends object>(\n  target: T,\n  handle: import('./types').LazyHandle,\n): T & import('./types').LazyHandle {\n  Object.defineProperties(target, {\n    preload: { value: handle.preload, enumerable: false },\n    status: { get: () => handle.status, enumerable: false },\n  });\n  return target as T & import('./types').LazyHandle;\n}\n"],"mappings":";;;;AAWA,SAAgB,YACd,OACA,QAAyB,sBAAsB,GAC/C,QACA;CACA,MAAM,KAAK,aAAa,MAAM;CAC9B,SAAS,OAAO,QAAoB,OAA2B;EAC7D,MAAM,KAAK;GACT;GACA,MAAM;GACN;GACA;GACA,YAAY,WAAW;GACvB,OAAO,SAAS,yBAAyB,KAAK;EAChD,CAAC;CACH;CACA,OAAO,YAAY;CACnB,IAAI,QAAQ,MAAM,KAAK,QAAQ,IAAI,UAAU;CAO7C,OAAO;EACL;EACA;EACA;GARA,mBAAmB,OAAO,SAAS;GACnC,qBAAqB,OAAO,UAAU;GACtC,cAAc,UAAU,OAAO,SAAS,KAAK;GAC7C,eAAe,MAAM,MAAM,EAAE;EAKzB;EACJ,SAAS,OAAe;GACtB,QAAQ;GACR,OAAO,YAAY;EACrB;CACF;AACF;AAEA,SAAgB,eACd,QACA,QACkC;CAClC,OAAO,iBAAiB,QAAQ;EAC9B,SAAS;GAAE,OAAO,OAAO;GAAS,YAAY;EAAM;EACpD,QAAQ;GAAE,WAAW,OAAO;GAAQ,YAAY;EAAM;CACxD,CAAC;CACD,OAAO;AACT"}

package/dist/lazy/lazy-boundary.cjs

@@ -0,0 +1,55 @@
+const require_lazy_resource_error = require('../errors/lazy-resource-error.cjs');
+let react = require("react");
+let react_jsx_runtime = require("react/jsx-runtime");
+
+//#region src/lazy/lazy-boundary.tsx
+var LazyErrorBoundary = class extends react.Component {
+	state = {
+		failed: false,
+		error: void 0
+	};
+	static getDerivedStateFromError(error) {
+		return {
+			failed: true,
+			error
+		};
+	}
+	retry = () => {
+		this.props.onRetry();
+		this.setState({
+			failed: false,
+			error: void 0
+		});
+	};
+	render() {
+		if (!this.state.failed) return this.props.children;
+		const { ErrorComponent, resource } = this.props;
+		if (!require_lazy_resource_error.isLazyResourceError(this.state.error) || !ErrorComponent) throw this.state.error;
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ErrorComponent, {
+			error: this.state.error,
+			retry: this.retry,
+			resource
+		});
+	}
+};
+/** Shared loading, typed error handling and retry for all lazy components. */
+function LazyBoundary({ loader, member, resource, fallback, ErrorComponent, componentProps, onMount, map }) {
+	const [, rerender] = (0, react.useReducer)((value) => value + 1, 0);
+	(0, react.useEffect)(() => onMount?.(), [onMount]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LazyErrorBoundary, {
+		resource,
+		ErrorComponent,
+		onRetry: () => {
+			loader.reset();
+			rerender();
+		},
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react.Suspense, {
+			fallback,
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(loader.component(member, map), { ...componentProps })
+		})
+	});
+}
+
+//#endregion
+exports.LazyBoundary = LazyBoundary;
+//# sourceMappingURL=lazy-boundary.cjs.map