@jfdevelops/react-layout 1.6.1 → 2.1.0

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,63 @@
+const require_render_state_context = require('../create-config/render-state-context.cjs');
+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)(require_render_state_context.RenderStateFallback, {
+			state: "Error",
+			children: /* @__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]);
+	const Current = loader.component(member, map);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LazyErrorBoundary, {
+		resource,
+		ErrorComponent,
+		onRetry: () => {
+			loader.reset();
+			rerender();
+		},
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react.Suspense, {
+			fallback: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_render_state_context.RenderStateFallback, {
+				state: "Loading",
+				children: fallback
+			}),
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Current, { ...componentProps })
+		})
+	});
+}
+
+//#endregion
+exports.LazyBoundary = LazyBoundary;
+//# sourceMappingURL=lazy-boundary.cjs.map

package/dist/lazy/lazy-boundary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-boundary.cjs","names":["Component","isLazyResourceError","RenderStateFallback","Suspense"],"sources":["../../src/lazy/lazy-boundary.tsx"],"sourcesContent":["import { RenderStateFallback } from '../create-config/render-state-context';\nimport {\n  Component,\n  Suspense,\n  useEffect,\n  useReducer,\n  type ReactNode,\n} from 'react';\nimport { isLazyResourceError } from '../errors/lazy-resource-error';\nimport type { LazyResourceErrorComponent } from './types';\nimport type { LazyLoader } from './create-lazy-loader';\n\ntype BoundaryProps = {\n  children: ReactNode;\n  ErrorComponent?: LazyResourceErrorComponent;\n  resource: string;\n  onRetry: () => void;\n};\n\nclass LazyErrorBoundary extends Component<\n  BoundaryProps,\n  { failed: boolean; error?: unknown }\n> {\n  state = { failed: false, error: undefined as unknown };\n  static getDerivedStateFromError(error: unknown) {\n    return { failed: true, error };\n  }\n  retry = () => {\n    this.props.onRetry();\n    this.setState({ failed: false, error: undefined });\n  };\n  render() {\n    if (!this.state.failed) return this.props.children;\n    const { ErrorComponent, resource } = this.props;\n    if (!isLazyResourceError(this.state.error) || !ErrorComponent)\n      throw this.state.error;\n    return (\n      <RenderStateFallback state=\"Error\">\n        <ErrorComponent\n          error={this.state.error}\n          retry={this.retry}\n          resource={resource}\n        />\n      </RenderStateFallback>\n    );\n  }\n}\n\n/** Shared loading, typed error handling and retry for all lazy components. */\nexport function LazyBoundary({\n  loader,\n  member,\n  resource,\n  fallback,\n  ErrorComponent,\n  componentProps,\n  onMount,\n  map,\n}: {\n  loader: LazyLoader<any>;\n  member?: PropertyKey;\n  map?: (selected: any) => React.ComponentType<any>;\n  resource: string;\n  fallback?: ReactNode;\n  ErrorComponent?: LazyResourceErrorComponent;\n  componentProps: Record<string, unknown>;\n  onMount?: () => (() => void) | undefined;\n}) {\n  const [, rerender] = useReducer((value) => value + 1, 0);\n  useEffect(() => onMount?.(), [onMount]);\n  const Current = loader.component(member, map);\n  return (\n    <LazyErrorBoundary\n      resource={resource}\n      ErrorComponent={ErrorComponent}\n      onRetry={() => {\n        loader.reset();\n        rerender();\n      }}\n    >\n      <Suspense fallback={\n        <RenderStateFallback state=\"Loading\">{fallback}</RenderStateFallback>\n      }>\n        <Current {...componentProps} />\n      </Suspense>\n    </LazyErrorBoundary>\n  );\n}\n"],"mappings":";;;;;;AAmBA,IAAM,oBAAN,cAAgCA,gBAG9B;CACA,QAAQ;EAAE,QAAQ;EAAO,OAAO;CAAqB;CACrD,OAAO,yBAAyB,OAAgB;EAC9C,OAAO;GAAE,QAAQ;GAAM;EAAM;CAC/B;CACA,cAAc;EACZ,KAAK,MAAM,QAAQ;EACnB,KAAK,SAAS;GAAE,QAAQ;GAAO,OAAO;EAAU,CAAC;CACnD;CACA,SAAS;EACP,IAAI,CAAC,KAAK,MAAM,QAAQ,OAAO,KAAK,MAAM;EAC1C,MAAM,EAAE,gBAAgB,aAAa,KAAK;EAC1C,IAAI,CAACC,gDAAoB,KAAK,MAAM,KAAK,KAAK,CAAC,gBAC7C,MAAM,KAAK,MAAM;EACnB,OACE,2CAACC,kDAAD;GAAqB,OAAM;aACzB,2CAAC,gBAAD;IACE,OAAO,KAAK,MAAM;IAClB,OAAO,KAAK;IACF;GACX;EACkB;CAEzB;AACF;;AAGA,SAAgB,aAAa,EAC3B,QACA,QACA,UACA,UACA,gBACA,gBACA,SACA,OAUC;CACD,MAAM,GAAG,mCAAwB,UAAU,QAAQ,GAAG,CAAC;CACvD,2BAAgB,UAAU,GAAG,CAAC,OAAO,CAAC;CACtC,MAAM,UAAU,OAAO,UAAU,QAAQ,GAAG;CAC5C,OACE,2CAAC,mBAAD;EACY;EACM;EAChB,eAAe;GACb,OAAO,MAAM;GACb,SAAS;EACX;YAEA,2CAACC,gBAAD;GAAU,UACR,2CAACD,kDAAD;IAAqB,OAAM;cAAW;GAA8B;aAEpE,2CAAC,SAAD,EAAS,GAAI,eAAiB;EACtB;CACO;AAEvB"}

package/dist/lazy/lazy-boundary.mjs

@@ -0,0 +1,63 @@
+import { RenderStateFallback } from "../create-config/render-state-context.mjs";
+import { isLazyResourceError } from "../errors/lazy-resource-error.mjs";
+import { Component, Suspense, useEffect, useReducer } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/lazy/lazy-boundary.tsx
+var LazyErrorBoundary = class extends 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 (!isLazyResourceError(this.state.error) || !ErrorComponent) throw this.state.error;
+		return /* @__PURE__ */ jsx(RenderStateFallback, {
+			state: "Error",
+			children: /* @__PURE__ */ 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] = useReducer((value) => value + 1, 0);
+	useEffect(() => onMount?.(), [onMount]);
+	const Current = loader.component(member, map);
+	return /* @__PURE__ */ jsx(LazyErrorBoundary, {
+		resource,
+		ErrorComponent,
+		onRetry: () => {
+			loader.reset();
+			rerender();
+		},
+		children: /* @__PURE__ */ jsx(Suspense, {
+			fallback: /* @__PURE__ */ jsx(RenderStateFallback, {
+				state: "Loading",
+				children: fallback
+			}),
+			children: /* @__PURE__ */ jsx(Current, { ...componentProps })
+		})
+	});
+}
+
+//#endregion
+export { LazyBoundary };
+//# sourceMappingURL=lazy-boundary.mjs.map

package/dist/lazy/lazy-boundary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-boundary.mjs","names":[],"sources":["../../src/lazy/lazy-boundary.tsx"],"sourcesContent":["import { RenderStateFallback } from '../create-config/render-state-context';\nimport {\n  Component,\n  Suspense,\n  useEffect,\n  useReducer,\n  type ReactNode,\n} from 'react';\nimport { isLazyResourceError } from '../errors/lazy-resource-error';\nimport type { LazyResourceErrorComponent } from './types';\nimport type { LazyLoader } from './create-lazy-loader';\n\ntype BoundaryProps = {\n  children: ReactNode;\n  ErrorComponent?: LazyResourceErrorComponent;\n  resource: string;\n  onRetry: () => void;\n};\n\nclass LazyErrorBoundary extends Component<\n  BoundaryProps,\n  { failed: boolean; error?: unknown }\n> {\n  state = { failed: false, error: undefined as unknown };\n  static getDerivedStateFromError(error: unknown) {\n    return { failed: true, error };\n  }\n  retry = () => {\n    this.props.onRetry();\n    this.setState({ failed: false, error: undefined });\n  };\n  render() {\n    if (!this.state.failed) return this.props.children;\n    const { ErrorComponent, resource } = this.props;\n    if (!isLazyResourceError(this.state.error) || !ErrorComponent)\n      throw this.state.error;\n    return (\n      <RenderStateFallback state=\"Error\">\n        <ErrorComponent\n          error={this.state.error}\n          retry={this.retry}\n          resource={resource}\n        />\n      </RenderStateFallback>\n    );\n  }\n}\n\n/** Shared loading, typed error handling and retry for all lazy components. */\nexport function LazyBoundary({\n  loader,\n  member,\n  resource,\n  fallback,\n  ErrorComponent,\n  componentProps,\n  onMount,\n  map,\n}: {\n  loader: LazyLoader<any>;\n  member?: PropertyKey;\n  map?: (selected: any) => React.ComponentType<any>;\n  resource: string;\n  fallback?: ReactNode;\n  ErrorComponent?: LazyResourceErrorComponent;\n  componentProps: Record<string, unknown>;\n  onMount?: () => (() => void) | undefined;\n}) {\n  const [, rerender] = useReducer((value) => value + 1, 0);\n  useEffect(() => onMount?.(), [onMount]);\n  const Current = loader.component(member, map);\n  return (\n    <LazyErrorBoundary\n      resource={resource}\n      ErrorComponent={ErrorComponent}\n      onRetry={() => {\n        loader.reset();\n        rerender();\n      }}\n    >\n      <Suspense fallback={\n        <RenderStateFallback state=\"Loading\">{fallback}</RenderStateFallback>\n      }>\n        <Current {...componentProps} />\n      </Suspense>\n    </LazyErrorBoundary>\n  );\n}\n"],"mappings":";;;;;;AAmBA,IAAM,oBAAN,cAAgC,UAG9B;CACA,QAAQ;EAAE,QAAQ;EAAO,OAAO;CAAqB;CACrD,OAAO,yBAAyB,OAAgB;EAC9C,OAAO;GAAE,QAAQ;GAAM;EAAM;CAC/B;CACA,cAAc;EACZ,KAAK,MAAM,QAAQ;EACnB,KAAK,SAAS;GAAE,QAAQ;GAAO,OAAO;EAAU,CAAC;CACnD;CACA,SAAS;EACP,IAAI,CAAC,KAAK,MAAM,QAAQ,OAAO,KAAK,MAAM;EAC1C,MAAM,EAAE,gBAAgB,aAAa,KAAK;EAC1C,IAAI,CAAC,oBAAoB,KAAK,MAAM,KAAK,KAAK,CAAC,gBAC7C,MAAM,KAAK,MAAM;EACnB,OACE,oBAAC,qBAAD;GAAqB,OAAM;aACzB,oBAAC,gBAAD;IACE,OAAO,KAAK,MAAM;IAClB,OAAO,KAAK;IACF;GACX;EACkB;CAEzB;AACF;;AAGA,SAAgB,aAAa,EAC3B,QACA,QACA,UACA,UACA,gBACA,gBACA,SACA,OAUC;CACD,MAAM,GAAG,YAAY,YAAY,UAAU,QAAQ,GAAG,CAAC;CACvD,gBAAgB,UAAU,GAAG,CAAC,OAAO,CAAC;CACtC,MAAM,UAAU,OAAO,UAAU,QAAQ,GAAG;CAC5C,OACE,oBAAC,mBAAD;EACY;EACM;EAChB,eAAe;GACb,OAAO,MAAM;GACb,SAAS;EACX;YAEA,oBAAC,UAAD;GAAU,UACR,oBAAC,qBAAD;IAAqB,OAAM;cAAW;GAA8B;aAEpE,oBAAC,SAAD,EAAS,GAAI,eAAiB;EACtB;CACO;AAEvB"}

package/dist/lazy/scoped-content.cjs

@@ -0,0 +1,87 @@
+const require_lazy_resource_error = require('../errors/lazy-resource-error.cjs');
+const require_lazy_boundary = require('./lazy-boundary.cjs');
+const require_fallback_props = require('./fallback-props.cjs');
+const require_create_lazy_loader = require('./create-lazy-loader.cjs');
+const require_inspection = require('./inspection.cjs');
+const require_render_state = require('../create-config/render-state.cjs');
+const require_scoped_render = require('../create-config/for-resources/scoped-render.cjs');
+let react = require("react");
+let react_jsx_runtime = require("react/jsx-runtime");
+let _jfdevelops_react_layout_devtools_core = require("@jfdevelops/react-layout-devtools-core");
+
+//#region src/lazy/scoped-content.tsx
+const scopedLazySymbol = Symbol("scopedLazy");
+/** Content is imported only when rendered or preloaded, never during shell creation. */
+function createScopedLazyContent(input, resource, label, environment) {
+	const options = typeof input.lazy === "function" ? { load: input.lazy } : input.lazy;
+	const componentId = environment?.store.node({
+		id: (0, _jfdevelops_react_layout_devtools_core.inspectionId)("component"),
+		kind: "component",
+		label,
+		details: { resource }
+	});
+	if (componentId && environment) environment.store.edge(environment.parent, componentId, "declares");
+	const inspection = require_inspection.inspectLazy(label, environment?.store, componentId);
+	if (componentId) inspection.hooks.onMount = () => inspection.store.mount(componentId, inspection.id);
+	const loader = require_create_lazy_loader.createLazyLoader({
+		load: options.load,
+		label,
+		hooks: inspection.hooks,
+		async select(module) {
+			const candidates = Object.values(module).filter((value) => require_scoped_render.isRenderableComponentType(value) || typeof value === "object" && value !== null && require_render_state.definedRenderStateSymbol in value);
+			if (candidates.length !== 1) throw new require_lazy_resource_error.LazyResourceModuleShapeError(label, candidates.length);
+			const selected = candidates[0];
+			const render = typeof selected === "object" && selected !== null && require_render_state.definedRenderStateSymbol in selected ? (await require_render_state.findDefinedRenderState({ State: selected }, label)).render : selected;
+			function Loaded({ callProps, context }) {
+				if (typeof render !== "function" || render.prototype?.isReactComponent) return (0, react.createElement)(render, callProps);
+				return require_scoped_render.resolveScopedRenderResult(render(callProps, context), callProps);
+			}
+			return Loaded;
+		}
+	});
+	const Content = require_inspection.withLazyHandle(function LazyScopedContent({ callProps, context }) {
+		const defaults = environment?.defaults() ?? {};
+		const currentProps = (0, react.useRef)(callProps);
+		currentProps.current = callProps;
+		const fallbackStates = (0, react.useRef)();
+		fallbackStates.current ??= environment?.states?.(resource, callProps) ?? {};
+		const nearest = fallbackStates.current;
+		const errorComponent = (0, react.useRef)();
+		const NearestError = nearest.Error;
+		if (NearestError && !errorComponent.current) errorComponent.current = function ScopedFallbackError(props) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_fallback_props.LazyFallbackPropsContext.Provider, {
+				value: {
+					owner: nearest.owner,
+					props: currentProps.current
+				},
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NearestError, { ...props })
+			});
+		};
+		const Loading = nearest.Loading ?? defaults.Loading;
+		const fallback = input.fallback !== void 0 ? input.fallback : options.fallback;
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_lazy_boundary.LazyBoundary, {
+			loader,
+			resource,
+			componentProps: {
+				callProps,
+				context
+			},
+			ErrorComponent: errorComponent.current ?? defaults.Error,
+			onMount: inspection.hooks.onMount,
+			fallback: fallback !== void 0 ? fallback : Loading ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_fallback_props.LazyFallbackPropsContext.Provider, {
+				value: {
+					owner: nearest.owner,
+					props: callProps
+				},
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Loading, { resource })
+			}) : null
+		});
+	}, loader);
+	inspection.store.attach(Content);
+	return Content;
+}
+
+//#endregion
+exports.createScopedLazyContent = createScopedLazyContent;
+exports.scopedLazySymbol = scopedLazySymbol;
+//# sourceMappingURL=scoped-content.cjs.map

package/dist/lazy/scoped-content.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-content.cjs","names":["inspectLazy","createLazyLoader","isRenderableComponentType","definedRenderStateSymbol","LazyResourceModuleShapeError","findDefinedRenderState","resolveScopedRenderResult","withLazyHandle","LazyFallbackPropsContext","LazyBoundary"],"sources":["../../src/lazy/scoped-content.tsx"],"sourcesContent":["import { LazyFallbackPropsContext } from './fallback-props';\nimport { createElement, useRef, type ComponentType } from 'react';\nimport type { LazyOptions, LazyResourceStates } from './types';\nimport { createLazyLoader } from './create-lazy-loader';\nimport { LazyBoundary } from './lazy-boundary';\nimport { inspectLazy, withLazyHandle } from './inspection';\nimport { LazyResourceModuleShapeError } from '../errors/lazy-resource-error';\nimport {\n  definedRenderStateSymbol,\n  findDefinedRenderState,\n} from '../create-config/render-state';\nimport {\n  isRenderableComponentType,\n  resolveScopedRenderResult,\n  type ScopedRenderResult,\n} from '../create-config/for-resources/scoped-render';\nimport {\n  inspectionId,\n  type InspectionStore,\n} from '@jfdevelops/react-layout-devtools-core';\n\nexport type ScopedComponentRenderFn<\n  Props = Record<string, unknown>,\n  Context = Record<string, ComponentType<any>>,\n> = (props: Props, context: Context) => ScopedRenderResult;\n\nexport type ScopedLazyContent<Render> =\n  | { render: Render; lazy?: never; fallback?: never }\n  | {\n      render?: never;\n      lazy: LazyOptions['load'] | LazyOptions;\n      fallback?: React.ReactNode;\n    };\n\nexport type LazyEnvironment = {\n  store: InspectionStore;\n  parent: string;\n  defaults: () => LazyResourceStates;\n  states?: (\n    resource: string,\n    props: Record<string, unknown>,\n  ) => LazyResourceStates & { owner?: string };\n};\n\nexport const scopedLazySymbol = Symbol('scopedLazy');\n\n/** Content is imported only when rendered or preloaded, never during shell creation. */\nexport function createScopedLazyContent(\n  input: {\n    lazy: LazyOptions['load'] | LazyOptions;\n    fallback?: React.ReactNode;\n  },\n  resource: string,\n  label: string,\n  environment?: LazyEnvironment,\n) {\n  const options =\n    typeof input.lazy === 'function' ? { load: input.lazy } : input.lazy;\n  const componentId = environment?.store.node({\n    id: inspectionId('component'),\n    kind: 'component',\n    label,\n    details: { resource },\n  });\n  if (componentId && environment) {\n    environment.store.edge(environment.parent, componentId, 'declares');\n  }\n  const inspection = inspectLazy(label, environment?.store, componentId);\n  if (componentId) {\n    inspection.hooks.onMount = () =>\n      inspection.store.mount(componentId, inspection.id);\n  }\n  const loader = createLazyLoader({\n    load: options.load,\n    label,\n    hooks: inspection.hooks,\n    async select(module) {\n      const candidates = Object.values(module).filter(\n        (value) =>\n          isRenderableComponentType(value) ||\n          (typeof value === 'object' &&\n            value !== null &&\n            definedRenderStateSymbol in value),\n      );\n      if (candidates.length !== 1)\n        throw new LazyResourceModuleShapeError(label, candidates.length);\n      const selected = candidates[0];\n      const render =\n        typeof selected === 'object' &&\n        selected !== null &&\n        definedRenderStateSymbol in selected\n          ? (await findDefinedRenderState({ State: selected }, label)).render\n          : (selected as ScopedComponentRenderFn);\n      // The render callback runs as a React component so hooks remain legal.\n      function Loaded({\n        callProps,\n        context,\n      }: {\n        callProps: Record<string, unknown>;\n        context: Record<string, ComponentType<any>>;\n      }) {\n        if (\n          typeof render !== 'function' ||\n          (render as unknown as { prototype?: { isReactComponent?: unknown } })\n            .prototype?.isReactComponent\n        )\n          return createElement(render as ComponentType<any>, callProps);\n        return resolveScopedRenderResult(render(callProps, context), callProps);\n      }\n      return Loaded;\n    },\n  });\n  const Content = withLazyHandle(function LazyScopedContent({\n    callProps,\n    context,\n  }: {\n    callProps: Record<string, unknown>;\n    context: Record<string, ComponentType<any>>;\n  }) {\n    const defaults = environment?.defaults() ?? {};\n    const currentProps = useRef(callProps);\n    currentProps.current = callProps;\n    const fallbackStates = useRef<LazyResourceStates & { owner?: string }>();\n    fallbackStates.current ??= environment?.states?.(resource, callProps) ?? {};\n    const nearest = fallbackStates.current;\n    const errorComponent = useRef<LazyResourceStates['Error']>();\n    const NearestError = nearest.Error;\n    if (NearestError && !errorComponent.current) {\n      errorComponent.current = function ScopedFallbackError(props) {\n        return (\n          <LazyFallbackPropsContext.Provider\n            value={{ owner: nearest.owner, props: currentProps.current }}\n          >\n            <NearestError {...props} />\n          </LazyFallbackPropsContext.Provider>\n        );\n      };\n    }\n    const Loading = nearest.Loading ?? defaults.Loading;\n    const fallback =\n      input.fallback !== undefined ? input.fallback : options.fallback;\n    return (\n      <LazyBoundary\n        loader={loader}\n        resource={resource}\n        componentProps={{ callProps, context }}\n        ErrorComponent={errorComponent.current ?? defaults.Error}\n        onMount={inspection.hooks.onMount}\n        fallback={\n          fallback !== undefined ? (\n            fallback\n          ) : Loading ? (\n            <LazyFallbackPropsContext.Provider\n              value={{ owner: nearest.owner, props: callProps }}\n            >\n              <Loading resource={resource} />\n            </LazyFallbackPropsContext.Provider>\n          ) : null\n        }\n      />\n    );\n  }, loader);\n  inspection.store.attach(Content);\n  return Content;\n}\n"],"mappings":";;;;;;;;;;;;AA4CA,MAAa,mBAAmB,OAAO,YAAY;;AAGnD,SAAgB,wBACd,OAIA,UACA,OACA,aACA;CACA,MAAM,UACJ,OAAO,MAAM,SAAS,aAAa,EAAE,MAAM,MAAM,KAAK,IAAI,MAAM;CAClE,MAAM,cAAc,aAAa,MAAM,KAAK;EAC1C,6DAAiB,WAAW;EAC5B,MAAM;EACN;EACA,SAAS,EAAE,SAAS;CACtB,CAAC;CACD,IAAI,eAAe,aACjB,YAAY,MAAM,KAAK,YAAY,QAAQ,aAAa,UAAU;CAEpE,MAAM,aAAaA,+BAAY,OAAO,aAAa,OAAO,WAAW;CACrE,IAAI,aACF,WAAW,MAAM,gBACf,WAAW,MAAM,MAAM,aAAa,WAAW,EAAE;CAErD,MAAM,SAASC,4CAAiB;EAC9B,MAAM,QAAQ;EACd;EACA,OAAO,WAAW;EAClB,MAAM,OAAO,QAAQ;GACnB,MAAM,aAAa,OAAO,OAAO,MAAM,EAAE,QACtC,UACCC,gDAA0B,KAAK,KAC9B,OAAO,UAAU,YAChB,UAAU,QACVC,iDAA4B,KAClC;GACA,IAAI,WAAW,WAAW,GACxB,MAAM,IAAIC,yDAA6B,OAAO,WAAW,MAAM;GACjE,MAAM,WAAW,WAAW;GAC5B,MAAM,SACJ,OAAO,aAAa,YACpB,aAAa,QACbD,iDAA4B,YACvB,MAAME,4CAAuB,EAAE,OAAO,SAAS,GAAG,KAAK,GAAG,SAC1D;GAEP,SAAS,OAAO,EACd,WACA,WAIC;IACD,IACE,OAAO,WAAW,cACjB,OACE,WAAW,kBAEd,gCAAqB,QAA8B,SAAS;IAC9D,OAAOC,gDAA0B,OAAO,WAAW,OAAO,GAAG,SAAS;GACxE;GACA,OAAO;EACT;CACF,CAAC;CACD,MAAM,UAAUC,kCAAe,SAAS,kBAAkB,EACxD,WACA,WAIC;EACD,MAAM,WAAW,aAAa,SAAS,KAAK,CAAC;EAC7C,MAAM,iCAAsB,SAAS;EACrC,aAAa,UAAU;EACvB,MAAM,mCAAiE;EACvE,eAAe,YAAY,aAAa,SAAS,UAAU,SAAS,KAAK,CAAC;EAC1E,MAAM,UAAU,eAAe;EAC/B,MAAM,mCAAqD;EAC3D,MAAM,eAAe,QAAQ;EAC7B,IAAI,gBAAgB,CAAC,eAAe,SAClC,eAAe,UAAU,SAAS,oBAAoB,OAAO;GAC3D,OACE,2CAACC,gDAAyB,UAA1B;IACE,OAAO;KAAE,OAAO,QAAQ;KAAO,OAAO,aAAa;IAAQ;cAE3D,2CAAC,cAAD,EAAc,GAAI,MAAQ;GACO;EAEvC;EAEF,MAAM,UAAU,QAAQ,WAAW,SAAS;EAC5C,MAAM,WACJ,MAAM,aAAa,SAAY,MAAM,WAAW,QAAQ;EAC1D,OACE,2CAACC,oCAAD;GACU;GACE;GACV,gBAAgB;IAAE;IAAW;GAAQ;GACrC,gBAAgB,eAAe,WAAW,SAAS;GACnD,SAAS,WAAW,MAAM;GAC1B,UACE,aAAa,SACX,WACE,UACF,2CAACD,gDAAyB,UAA1B;IACE,OAAO;KAAE,OAAO,QAAQ;KAAO,OAAO;IAAU;cAEhD,2CAAC,SAAD,EAAmB,SAAW;GACG,KACjC;EAEP;CAEL,GAAG,MAAM;CACT,WAAW,MAAM,OAAO,OAAO;CAC/B,OAAO;AACT"}

package/dist/lazy/scoped-content.d.cts

@@ -0,0 +1,19 @@
+import { LazyOptions } from "./types.cjs";
+import { ScopedRenderResult } from "../create-config/for-resources/scoped-render.cjs";
+import { ComponentType } from "react";
+import { InspectionStore } from "@jfdevelops/react-layout-devtools-core";
+
+//#region src/lazy/scoped-content.d.ts
+type ScopedComponentRenderFn<Props = Record<string, unknown>, Context = Record<string, ComponentType<any>>> = (props: Props, context: Context) => ScopedRenderResult;
+type ScopedLazyContent<Render> = {
+  render: Render;
+  lazy?: never;
+  fallback?: never;
+} | {
+  render?: never;
+  lazy: LazyOptions['load'] | LazyOptions;
+  fallback?: React.ReactNode;
+};
+//#endregion
+export { ScopedComponentRenderFn, ScopedLazyContent };
+//# sourceMappingURL=scoped-content.d.cts.map

package/dist/lazy/scoped-content.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-content.d.cts","names":[],"sources":["../../src/lazy/scoped-content.tsx"],"mappings":";;;;;;KAqBY,uBAAA,SACF,MAAA,6BACE,MAAA,SAAe,aAAA,WACtB,KAAA,EAAO,KAAA,EAAO,OAAA,EAAS,OAAA,KAAY,kBAAA;AAAA,KAE5B,iBAAA;EACN,MAAA,EAAQ,MAAA;EAAQ,IAAA;EAAc,QAAA;AAAA;EAE9B,MAAA;EACA,IAAA,EAAM,WAAA,WAAsB,WAAA;EAC5B,QAAA,GAAW,KAAA,CAAM,SAAA;AAAA"}

package/dist/lazy/scoped-content.d.mts

@@ -0,0 +1,19 @@
+import { LazyOptions } from "./types.mjs";
+import { ScopedRenderResult } from "../create-config/for-resources/scoped-render.mjs";
+import { ComponentType } from "react";
+import { InspectionStore } from "@jfdevelops/react-layout-devtools-core";
+
+//#region src/lazy/scoped-content.d.ts
+type ScopedComponentRenderFn<Props = Record<string, unknown>, Context = Record<string, ComponentType<any>>> = (props: Props, context: Context) => ScopedRenderResult;
+type ScopedLazyContent<Render> = {
+  render: Render;
+  lazy?: never;
+  fallback?: never;
+} | {
+  render?: never;
+  lazy: LazyOptions['load'] | LazyOptions;
+  fallback?: React.ReactNode;
+};
+//#endregion
+export { ScopedComponentRenderFn, ScopedLazyContent };
+//# sourceMappingURL=scoped-content.d.mts.map

package/dist/lazy/scoped-content.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-content.d.mts","names":[],"sources":["../../src/lazy/scoped-content.tsx"],"mappings":";;;;;;KAqBY,uBAAA,SACF,MAAA,6BACE,MAAA,SAAe,aAAA,WACtB,KAAA,EAAO,KAAA,EAAO,OAAA,EAAS,OAAA,KAAY,kBAAA;AAAA,KAE5B,iBAAA;EACN,MAAA,EAAQ,MAAA;EAAQ,IAAA;EAAc,QAAA;AAAA;EAE9B,MAAA;EACA,IAAA,EAAM,WAAA,WAAsB,WAAA;EAC5B,QAAA,GAAW,KAAA,CAAM,SAAA;AAAA"}

package/dist/lazy/scoped-content.mjs

@@ -0,0 +1,86 @@
+import { LazyResourceModuleShapeError } from "../errors/lazy-resource-error.mjs";
+import { LazyBoundary } from "./lazy-boundary.mjs";
+import { LazyFallbackPropsContext } from "./fallback-props.mjs";
+import { createLazyLoader } from "./create-lazy-loader.mjs";
+import { inspectLazy, withLazyHandle } from "./inspection.mjs";
+import { definedRenderStateSymbol, findDefinedRenderState } from "../create-config/render-state.mjs";
+import { isRenderableComponentType, resolveScopedRenderResult } from "../create-config/for-resources/scoped-render.mjs";
+import { createElement, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+import { inspectionId } from "@jfdevelops/react-layout-devtools-core";
+
+//#region src/lazy/scoped-content.tsx
+const scopedLazySymbol = Symbol("scopedLazy");
+/** Content is imported only when rendered or preloaded, never during shell creation. */
+function createScopedLazyContent(input, resource, label, environment) {
+	const options = typeof input.lazy === "function" ? { load: input.lazy } : input.lazy;
+	const componentId = environment?.store.node({
+		id: inspectionId("component"),
+		kind: "component",
+		label,
+		details: { resource }
+	});
+	if (componentId && environment) environment.store.edge(environment.parent, componentId, "declares");
+	const inspection = inspectLazy(label, environment?.store, componentId);
+	if (componentId) inspection.hooks.onMount = () => inspection.store.mount(componentId, inspection.id);
+	const loader = createLazyLoader({
+		load: options.load,
+		label,
+		hooks: inspection.hooks,
+		async select(module) {
+			const candidates = Object.values(module).filter((value) => isRenderableComponentType(value) || typeof value === "object" && value !== null && definedRenderStateSymbol in value);
+			if (candidates.length !== 1) throw new LazyResourceModuleShapeError(label, candidates.length);
+			const selected = candidates[0];
+			const render = typeof selected === "object" && selected !== null && definedRenderStateSymbol in selected ? (await findDefinedRenderState({ State: selected }, label)).render : selected;
+			function Loaded({ callProps, context }) {
+				if (typeof render !== "function" || render.prototype?.isReactComponent) return createElement(render, callProps);
+				return resolveScopedRenderResult(render(callProps, context), callProps);
+			}
+			return Loaded;
+		}
+	});
+	const Content = withLazyHandle(function LazyScopedContent({ callProps, context }) {
+		const defaults = environment?.defaults() ?? {};
+		const currentProps = useRef(callProps);
+		currentProps.current = callProps;
+		const fallbackStates = useRef();
+		fallbackStates.current ??= environment?.states?.(resource, callProps) ?? {};
+		const nearest = fallbackStates.current;
+		const errorComponent = useRef();
+		const NearestError = nearest.Error;
+		if (NearestError && !errorComponent.current) errorComponent.current = function ScopedFallbackError(props) {
+			return /* @__PURE__ */ jsx(LazyFallbackPropsContext.Provider, {
+				value: {
+					owner: nearest.owner,
+					props: currentProps.current
+				},
+				children: /* @__PURE__ */ jsx(NearestError, { ...props })
+			});
+		};
+		const Loading = nearest.Loading ?? defaults.Loading;
+		const fallback = input.fallback !== void 0 ? input.fallback : options.fallback;
+		return /* @__PURE__ */ jsx(LazyBoundary, {
+			loader,
+			resource,
+			componentProps: {
+				callProps,
+				context
+			},
+			ErrorComponent: errorComponent.current ?? defaults.Error,
+			onMount: inspection.hooks.onMount,
+			fallback: fallback !== void 0 ? fallback : Loading ? /* @__PURE__ */ jsx(LazyFallbackPropsContext.Provider, {
+				value: {
+					owner: nearest.owner,
+					props: callProps
+				},
+				children: /* @__PURE__ */ jsx(Loading, { resource })
+			}) : null
+		});
+	}, loader);
+	inspection.store.attach(Content);
+	return Content;
+}
+
+//#endregion
+export { createScopedLazyContent, scopedLazySymbol };
+//# sourceMappingURL=scoped-content.mjs.map

package/dist/lazy/scoped-content.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-content.mjs","names":[],"sources":["../../src/lazy/scoped-content.tsx"],"sourcesContent":["import { LazyFallbackPropsContext } from './fallback-props';\nimport { createElement, useRef, type ComponentType } from 'react';\nimport type { LazyOptions, LazyResourceStates } from './types';\nimport { createLazyLoader } from './create-lazy-loader';\nimport { LazyBoundary } from './lazy-boundary';\nimport { inspectLazy, withLazyHandle } from './inspection';\nimport { LazyResourceModuleShapeError } from '../errors/lazy-resource-error';\nimport {\n  definedRenderStateSymbol,\n  findDefinedRenderState,\n} from '../create-config/render-state';\nimport {\n  isRenderableComponentType,\n  resolveScopedRenderResult,\n  type ScopedRenderResult,\n} from '../create-config/for-resources/scoped-render';\nimport {\n  inspectionId,\n  type InspectionStore,\n} from '@jfdevelops/react-layout-devtools-core';\n\nexport type ScopedComponentRenderFn<\n  Props = Record<string, unknown>,\n  Context = Record<string, ComponentType<any>>,\n> = (props: Props, context: Context) => ScopedRenderResult;\n\nexport type ScopedLazyContent<Render> =\n  | { render: Render; lazy?: never; fallback?: never }\n  | {\n      render?: never;\n      lazy: LazyOptions['load'] | LazyOptions;\n      fallback?: React.ReactNode;\n    };\n\nexport type LazyEnvironment = {\n  store: InspectionStore;\n  parent: string;\n  defaults: () => LazyResourceStates;\n  states?: (\n    resource: string,\n    props: Record<string, unknown>,\n  ) => LazyResourceStates & { owner?: string };\n};\n\nexport const scopedLazySymbol = Symbol('scopedLazy');\n\n/** Content is imported only when rendered or preloaded, never during shell creation. */\nexport function createScopedLazyContent(\n  input: {\n    lazy: LazyOptions['load'] | LazyOptions;\n    fallback?: React.ReactNode;\n  },\n  resource: string,\n  label: string,\n  environment?: LazyEnvironment,\n) {\n  const options =\n    typeof input.lazy === 'function' ? { load: input.lazy } : input.lazy;\n  const componentId = environment?.store.node({\n    id: inspectionId('component'),\n    kind: 'component',\n    label,\n    details: { resource },\n  });\n  if (componentId && environment) {\n    environment.store.edge(environment.parent, componentId, 'declares');\n  }\n  const inspection = inspectLazy(label, environment?.store, componentId);\n  if (componentId) {\n    inspection.hooks.onMount = () =>\n      inspection.store.mount(componentId, inspection.id);\n  }\n  const loader = createLazyLoader({\n    load: options.load,\n    label,\n    hooks: inspection.hooks,\n    async select(module) {\n      const candidates = Object.values(module).filter(\n        (value) =>\n          isRenderableComponentType(value) ||\n          (typeof value === 'object' &&\n            value !== null &&\n            definedRenderStateSymbol in value),\n      );\n      if (candidates.length !== 1)\n        throw new LazyResourceModuleShapeError(label, candidates.length);\n      const selected = candidates[0];\n      const render =\n        typeof selected === 'object' &&\n        selected !== null &&\n        definedRenderStateSymbol in selected\n          ? (await findDefinedRenderState({ State: selected }, label)).render\n          : (selected as ScopedComponentRenderFn);\n      // The render callback runs as a React component so hooks remain legal.\n      function Loaded({\n        callProps,\n        context,\n      }: {\n        callProps: Record<string, unknown>;\n        context: Record<string, ComponentType<any>>;\n      }) {\n        if (\n          typeof render !== 'function' ||\n          (render as unknown as { prototype?: { isReactComponent?: unknown } })\n            .prototype?.isReactComponent\n        )\n          return createElement(render as ComponentType<any>, callProps);\n        return resolveScopedRenderResult(render(callProps, context), callProps);\n      }\n      return Loaded;\n    },\n  });\n  const Content = withLazyHandle(function LazyScopedContent({\n    callProps,\n    context,\n  }: {\n    callProps: Record<string, unknown>;\n    context: Record<string, ComponentType<any>>;\n  }) {\n    const defaults = environment?.defaults() ?? {};\n    const currentProps = useRef(callProps);\n    currentProps.current = callProps;\n    const fallbackStates = useRef<LazyResourceStates & { owner?: string }>();\n    fallbackStates.current ??= environment?.states?.(resource, callProps) ?? {};\n    const nearest = fallbackStates.current;\n    const errorComponent = useRef<LazyResourceStates['Error']>();\n    const NearestError = nearest.Error;\n    if (NearestError && !errorComponent.current) {\n      errorComponent.current = function ScopedFallbackError(props) {\n        return (\n          <LazyFallbackPropsContext.Provider\n            value={{ owner: nearest.owner, props: currentProps.current }}\n          >\n            <NearestError {...props} />\n          </LazyFallbackPropsContext.Provider>\n        );\n      };\n    }\n    const Loading = nearest.Loading ?? defaults.Loading;\n    const fallback =\n      input.fallback !== undefined ? input.fallback : options.fallback;\n    return (\n      <LazyBoundary\n        loader={loader}\n        resource={resource}\n        componentProps={{ callProps, context }}\n        ErrorComponent={errorComponent.current ?? defaults.Error}\n        onMount={inspection.hooks.onMount}\n        fallback={\n          fallback !== undefined ? (\n            fallback\n          ) : Loading ? (\n            <LazyFallbackPropsContext.Provider\n              value={{ owner: nearest.owner, props: callProps }}\n            >\n              <Loading resource={resource} />\n            </LazyFallbackPropsContext.Provider>\n          ) : null\n        }\n      />\n    );\n  }, loader);\n  inspection.store.attach(Content);\n  return Content;\n}\n"],"mappings":";;;;;;;;;;;;AA4CA,MAAa,mBAAmB,OAAO,YAAY;;AAGnD,SAAgB,wBACd,OAIA,UACA,OACA,aACA;CACA,MAAM,UACJ,OAAO,MAAM,SAAS,aAAa,EAAE,MAAM,MAAM,KAAK,IAAI,MAAM;CAClE,MAAM,cAAc,aAAa,MAAM,KAAK;EAC1C,IAAI,aAAa,WAAW;EAC5B,MAAM;EACN;EACA,SAAS,EAAE,SAAS;CACtB,CAAC;CACD,IAAI,eAAe,aACjB,YAAY,MAAM,KAAK,YAAY,QAAQ,aAAa,UAAU;CAEpE,MAAM,aAAa,YAAY,OAAO,aAAa,OAAO,WAAW;CACrE,IAAI,aACF,WAAW,MAAM,gBACf,WAAW,MAAM,MAAM,aAAa,WAAW,EAAE;CAErD,MAAM,SAAS,iBAAiB;EAC9B,MAAM,QAAQ;EACd;EACA,OAAO,WAAW;EAClB,MAAM,OAAO,QAAQ;GACnB,MAAM,aAAa,OAAO,OAAO,MAAM,EAAE,QACtC,UACC,0BAA0B,KAAK,KAC9B,OAAO,UAAU,YAChB,UAAU,QACV,4BAA4B,KAClC;GACA,IAAI,WAAW,WAAW,GACxB,MAAM,IAAI,6BAA6B,OAAO,WAAW,MAAM;GACjE,MAAM,WAAW,WAAW;GAC5B,MAAM,SACJ,OAAO,aAAa,YACpB,aAAa,QACb,4BAA4B,YACvB,MAAM,uBAAuB,EAAE,OAAO,SAAS,GAAG,KAAK,GAAG,SAC1D;GAEP,SAAS,OAAO,EACd,WACA,WAIC;IACD,IACE,OAAO,WAAW,cACjB,OACE,WAAW,kBAEd,OAAO,cAAc,QAA8B,SAAS;IAC9D,OAAO,0BAA0B,OAAO,WAAW,OAAO,GAAG,SAAS;GACxE;GACA,OAAO;EACT;CACF,CAAC;CACD,MAAM,UAAU,eAAe,SAAS,kBAAkB,EACxD,WACA,WAIC;EACD,MAAM,WAAW,aAAa,SAAS,KAAK,CAAC;EAC7C,MAAM,eAAe,OAAO,SAAS;EACrC,aAAa,UAAU;EACvB,MAAM,iBAAiB,OAAgD;EACvE,eAAe,YAAY,aAAa,SAAS,UAAU,SAAS,KAAK,CAAC;EAC1E,MAAM,UAAU,eAAe;EAC/B,MAAM,iBAAiB,OAAoC;EAC3D,MAAM,eAAe,QAAQ;EAC7B,IAAI,gBAAgB,CAAC,eAAe,SAClC,eAAe,UAAU,SAAS,oBAAoB,OAAO;GAC3D,OACE,oBAAC,yBAAyB,UAA1B;IACE,OAAO;KAAE,OAAO,QAAQ;KAAO,OAAO,aAAa;IAAQ;cAE3D,oBAAC,cAAD,EAAc,GAAI,MAAQ;GACO;EAEvC;EAEF,MAAM,UAAU,QAAQ,WAAW,SAAS;EAC5C,MAAM,WACJ,MAAM,aAAa,SAAY,MAAM,WAAW,QAAQ;EAC1D,OACE,oBAAC,cAAD;GACU;GACE;GACV,gBAAgB;IAAE;IAAW;GAAQ;GACrC,gBAAgB,eAAe,WAAW,SAAS;GACnD,SAAS,WAAW,MAAM;GAC1B,UACE,aAAa,SACX,WACE,UACF,oBAAC,yBAAyB,UAA1B;IACE,OAAO;KAAE,OAAO,QAAQ;KAAO,OAAO;IAAU;cAEhD,oBAAC,SAAD,EAAmB,SAAW;GACG,KACjC;EAEP;CAEL,GAAG,MAAM;CACT,WAAW,MAAM,OAAO,OAAO;CAC/B,OAAO;AACT"}

package/dist/lazy/types.cjs

@@ -0,0 +1,10 @@
+
+//#region src/lazy/types.ts
+/** Internal factory defaults propagated to layouts without publishing metadata. */
+const lazyDefaultsSymbol = Symbol("lazyDefaults");
+const lazyStatesSymbol = Symbol("lazyStates");
+
+//#endregion
+exports.lazyDefaultsSymbol = lazyDefaultsSymbol;
+exports.lazyStatesSymbol = lazyStatesSymbol;
+//# sourceMappingURL=types.cjs.map

package/dist/lazy/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.cjs","names":[],"sources":["../../src/lazy/types.ts"],"sourcesContent":["import type { ComponentType, ReactNode } from 'react';\nimport type { LoadStatus } from '@jfdevelops/react-layout-devtools-core';\nimport type {\n  LazyResourceError,\n  LazyResourceErrorMap,\n} from '../errors/lazy-resource-error';\n\nexport type { LoadStatus } from '@jfdevelops/react-layout-devtools-core';\n\n/** Options shared by lazy layouts, render states, and scoped content. */\nexport type LazyOptions<\n  Module extends Record<string, unknown> = Record<string, unknown>,\n> = {\n  load: () => Promise<Module>;\n  fallback?: ReactNode;\n};\n\nexport type LazyHandle = {\n  preload(): Promise<void>;\n  readonly status: LoadStatus;\n};\n\nexport type LazyResourceErrorProps<Resource = string> = {\n  error: LazyResourceError;\n  retry: () => void;\n  resource: Resource;\n};\n\nexport type LazyResourceErrorComponent<Resource = string> = ComponentType<\n  LazyResourceErrorProps<Resource>\n>;\nexport type LazyResourceLoadingComponent<Resource = string> = ComponentType<{\n  resource: Resource;\n}>;\nexport type LazyResourceStates<Resource = string> = {\n  Error?: LazyResourceErrorComponent<Resource>;\n  Loading?: LazyResourceLoadingComponent<Resource>;\n};\n\ntype ErrorHandlerContext<Context> = [Context] extends [never]\n  ? []\n  : [context: Context];\n\nexport type LazyErrorHandlers<\n  Resource,\n  Custom extends object = {},\n  Context = never,\n> = {\n  [Code in LazyResourceError['code']]?: (\n    props: Custom &\n      Omit<LazyResourceErrorProps<Resource>, 'error'> & {\n        error: LazyResourceErrorMap[Code];\n      },\n    ...context: ErrorHandlerContext<Context>\n  ) => ReactNode;\n} & {\n  fallback?: (\n    props: Custom & LazyResourceErrorProps<Resource>,\n    ...context: ErrorHandlerContext<Context>\n  ) => ReactNode;\n};\n\nexport type CreateLazyErrorComponent<Resource, Context = never> = {\n  <Custom extends object = {}>(\n    render: (\n      props: Custom & LazyResourceErrorProps<Resource>,\n      ...context: ErrorHandlerContext<Context>\n    ) => ReactNode,\n  ): ComponentType<Custom & LazyResourceErrorProps<Resource>>;\n  <Custom extends object = {}>(\n    handlers: LazyErrorHandlers<Resource, Custom, Context>,\n  ): ComponentType<Custom & LazyResourceErrorProps<Resource>>;\n};\n\n/** Internal factory defaults propagated to layouts without publishing metadata. */\nexport const lazyDefaultsSymbol = Symbol('lazyDefaults');\n\nexport const lazyStatesSymbol = Symbol('lazyStates');\n"],"mappings":";;;AA2EA,MAAa,qBAAqB,OAAO,cAAc;AAEvD,MAAa,mBAAmB,OAAO,YAAY"}

package/dist/lazy/types.d.cts

@@ -0,0 +1,40 @@
+import { LazyResourceError, LazyResourceErrorMap } from "../errors/lazy-resource-error.cjs";
+import { ComponentType, ReactNode } from "react";
+import { LoadStatus, LoadStatus as LoadStatus$1 } from "@jfdevelops/react-layout-devtools-core";
+
+//#region src/lazy/types.d.ts
+/** Options shared by lazy layouts, render states, and scoped content. */
+type LazyOptions<Module extends Record<string, unknown> = Record<string, unknown>> = {
+  load: () => Promise<Module>;
+  fallback?: ReactNode;
+};
+type LazyHandle = {
+  preload(): Promise<void>;
+  readonly status: LoadStatus;
+};
+type LazyResourceErrorProps<Resource = string> = {
+  error: LazyResourceError;
+  retry: () => void;
+  resource: Resource;
+};
+type LazyResourceErrorComponent<Resource = string> = ComponentType<LazyResourceErrorProps<Resource>>;
+type LazyResourceLoadingComponent<Resource = string> = ComponentType<{
+  resource: Resource;
+}>;
+type LazyResourceStates<Resource = string> = {
+  Error?: LazyResourceErrorComponent<Resource>;
+  Loading?: LazyResourceLoadingComponent<Resource>;
+};
+type ErrorHandlerContext<Context> = [Context] extends [never] ? [] : [context: Context];
+type LazyErrorHandlers<Resource, Custom extends object = {}, Context = never> = { [Code in LazyResourceError['code']]?: (props: Custom & Omit<LazyResourceErrorProps<Resource>, 'error'> & {
+  error: LazyResourceErrorMap[Code];
+}, ...context: ErrorHandlerContext<Context>) => ReactNode } & {
+  fallback?: (props: Custom & LazyResourceErrorProps<Resource>, ...context: ErrorHandlerContext<Context>) => ReactNode;
+};
+type CreateLazyErrorComponent<Resource, Context = never> = {
+  <Custom extends object = {}>(render: (props: Custom & LazyResourceErrorProps<Resource>, ...context: ErrorHandlerContext<Context>) => ReactNode): ComponentType<Custom & LazyResourceErrorProps<Resource>>;
+  <Custom extends object = {}>(handlers: LazyErrorHandlers<Resource, Custom, Context>): ComponentType<Custom & LazyResourceErrorProps<Resource>>;
+};
+//#endregion
+export { CreateLazyErrorComponent, LazyErrorHandlers, LazyHandle, LazyOptions, LazyResourceErrorComponent, LazyResourceErrorProps, LazyResourceLoadingComponent, LazyResourceStates, type LoadStatus$1 as LoadStatus };
+//# sourceMappingURL=types.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/lazy/types.ts"],"mappings":";;;;;;KAUY,WAAA,gBACK,MAAA,oBAA0B,MAAA;EAEzC,IAAA,QAAY,OAAA,CAAQ,MAAA;EACpB,QAAA,GAAW,SAAA;AAAA;AAAA,KAGD,UAAA;EACV,OAAA,IAAW,OAAA;EAAA,SACF,MAAA,EAAQ,UAAU;AAAA;AAAA,KAGjB,sBAAA;EACV,KAAA,EAAO,iBAAA;EACP,KAAA;EACA,QAAA,EAAU,QAAQ;AAAA;AAAA,KAGR,0BAAA,sBAAgD,aAAA,CAC1D,sBAAA,CAAuB,QAAA;AAAA,KAEb,4BAAA,sBAAkD,aAAa;EACzE,QAAA,EAAU,QAAA;AAAA;AAAA,KAEA,kBAAA;EACV,KAAA,GAAQ,0BAAA,CAA2B,QAAA;EACnC,OAAA,GAAU,4BAAA,CAA6B,QAAA;AAAA;AAAA,KAGpC,mBAAA,aAAgC,OAAA,0BAEhC,OAAA,EAAS,OAAO;AAAA,KAET,iBAAA,qEAKD,iBAAA,aACP,KAAA,EAAO,MAAA,GACL,IAAA,CAAK,sBAAA,CAAuB,QAAA;EAC1B,KAAA,EAAO,oBAAA,CAAqB,IAAA;AAAA,MAE7B,OAAA,EAAS,mBAAA,CAAoB,OAAA,MAC7B,SAAA;EAEL,QAAA,IACE,KAAA,EAAO,MAAA,GAAS,sBAAA,CAAuB,QAAA,MACpC,OAAA,EAAS,mBAAA,CAAoB,OAAA,MAC7B,SAAA;AAAA;AAAA,KAGK,wBAAA;EAAA,6BAER,MAAA,GACE,KAAA,EAAO,MAAA,GAAS,sBAAA,CAAuB,QAAA,MACpC,OAAA,EAAS,mBAAA,CAAoB,OAAA,MAC7B,SAAA,GACJ,aAAA,CAAc,MAAA,GAAS,sBAAA,CAAuB,QAAA;EAAA,6BAE/C,QAAA,EAAU,iBAAA,CAAkB,QAAA,EAAU,MAAA,EAAQ,OAAA,IAC7C,aAAA,CAAc,MAAA,GAAS,sBAAA,CAAuB,QAAA;AAAA"}

package/dist/lazy/types.d.mts

@@ -0,0 +1,40 @@
+import { LazyResourceError, LazyResourceErrorMap } from "../errors/lazy-resource-error.mjs";
+import { ComponentType, ReactNode } from "react";
+import { LoadStatus, LoadStatus as LoadStatus$1 } from "@jfdevelops/react-layout-devtools-core";
+
+//#region src/lazy/types.d.ts
+/** Options shared by lazy layouts, render states, and scoped content. */
+type LazyOptions<Module extends Record<string, unknown> = Record<string, unknown>> = {
+  load: () => Promise<Module>;
+  fallback?: ReactNode;
+};
+type LazyHandle = {
+  preload(): Promise<void>;
+  readonly status: LoadStatus;
+};
+type LazyResourceErrorProps<Resource = string> = {
+  error: LazyResourceError;
+  retry: () => void;
+  resource: Resource;
+};
+type LazyResourceErrorComponent<Resource = string> = ComponentType<LazyResourceErrorProps<Resource>>;
+type LazyResourceLoadingComponent<Resource = string> = ComponentType<{
+  resource: Resource;
+}>;
+type LazyResourceStates<Resource = string> = {
+  Error?: LazyResourceErrorComponent<Resource>;
+  Loading?: LazyResourceLoadingComponent<Resource>;
+};
+type ErrorHandlerContext<Context> = [Context] extends [never] ? [] : [context: Context];
+type LazyErrorHandlers<Resource, Custom extends object = {}, Context = never> = { [Code in LazyResourceError['code']]?: (props: Custom & Omit<LazyResourceErrorProps<Resource>, 'error'> & {
+  error: LazyResourceErrorMap[Code];
+}, ...context: ErrorHandlerContext<Context>) => ReactNode } & {
+  fallback?: (props: Custom & LazyResourceErrorProps<Resource>, ...context: ErrorHandlerContext<Context>) => ReactNode;
+};
+type CreateLazyErrorComponent<Resource, Context = never> = {
+  <Custom extends object = {}>(render: (props: Custom & LazyResourceErrorProps<Resource>, ...context: ErrorHandlerContext<Context>) => ReactNode): ComponentType<Custom & LazyResourceErrorProps<Resource>>;
+  <Custom extends object = {}>(handlers: LazyErrorHandlers<Resource, Custom, Context>): ComponentType<Custom & LazyResourceErrorProps<Resource>>;
+};
+//#endregion
+export { CreateLazyErrorComponent, LazyErrorHandlers, LazyHandle, LazyOptions, LazyResourceErrorComponent, LazyResourceErrorProps, LazyResourceLoadingComponent, LazyResourceStates, type LoadStatus$1 as LoadStatus };
+//# sourceMappingURL=types.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/lazy/types.ts"],"mappings":";;;;;;KAUY,WAAA,gBACK,MAAA,oBAA0B,MAAA;EAEzC,IAAA,QAAY,OAAA,CAAQ,MAAA;EACpB,QAAA,GAAW,SAAA;AAAA;AAAA,KAGD,UAAA;EACV,OAAA,IAAW,OAAA;EAAA,SACF,MAAA,EAAQ,UAAU;AAAA;AAAA,KAGjB,sBAAA;EACV,KAAA,EAAO,iBAAA;EACP,KAAA;EACA,QAAA,EAAU,QAAQ;AAAA;AAAA,KAGR,0BAAA,sBAAgD,aAAA,CAC1D,sBAAA,CAAuB,QAAA;AAAA,KAEb,4BAAA,sBAAkD,aAAa;EACzE,QAAA,EAAU,QAAA;AAAA;AAAA,KAEA,kBAAA;EACV,KAAA,GAAQ,0BAAA,CAA2B,QAAA;EACnC,OAAA,GAAU,4BAAA,CAA6B,QAAA;AAAA;AAAA,KAGpC,mBAAA,aAAgC,OAAA,0BAEhC,OAAA,EAAS,OAAO;AAAA,KAET,iBAAA,qEAKD,iBAAA,aACP,KAAA,EAAO,MAAA,GACL,IAAA,CAAK,sBAAA,CAAuB,QAAA;EAC1B,KAAA,EAAO,oBAAA,CAAqB,IAAA;AAAA,MAE7B,OAAA,EAAS,mBAAA,CAAoB,OAAA,MAC7B,SAAA;EAEL,QAAA,IACE,KAAA,EAAO,MAAA,GAAS,sBAAA,CAAuB,QAAA,MACpC,OAAA,EAAS,mBAAA,CAAoB,OAAA,MAC7B,SAAA;AAAA;AAAA,KAGK,wBAAA;EAAA,6BAER,MAAA,GACE,KAAA,EAAO,MAAA,GAAS,sBAAA,CAAuB,QAAA,MACpC,OAAA,EAAS,mBAAA,CAAoB,OAAA,MAC7B,SAAA,GACJ,aAAA,CAAc,MAAA,GAAS,sBAAA,CAAuB,QAAA;EAAA,6BAE/C,QAAA,EAAU,iBAAA,CAAkB,QAAA,EAAU,MAAA,EAAQ,OAAA,IAC7C,aAAA,CAAc,MAAA,GAAS,sBAAA,CAAuB,QAAA;AAAA"}

package/dist/lazy/types.mjs

@@ -0,0 +1,8 @@
+//#region src/lazy/types.ts
+/** Internal factory defaults propagated to layouts without publishing metadata. */
+const lazyDefaultsSymbol = Symbol("lazyDefaults");
+const lazyStatesSymbol = Symbol("lazyStates");
+
+//#endregion
+export { lazyDefaultsSymbol, lazyStatesSymbol };
+//# sourceMappingURL=types.mjs.map

package/dist/lazy/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","names":[],"sources":["../../src/lazy/types.ts"],"sourcesContent":["import type { ComponentType, ReactNode } from 'react';\nimport type { LoadStatus } from '@jfdevelops/react-layout-devtools-core';\nimport type {\n  LazyResourceError,\n  LazyResourceErrorMap,\n} from '../errors/lazy-resource-error';\n\nexport type { LoadStatus } from '@jfdevelops/react-layout-devtools-core';\n\n/** Options shared by lazy layouts, render states, and scoped content. */\nexport type LazyOptions<\n  Module extends Record<string, unknown> = Record<string, unknown>,\n> = {\n  load: () => Promise<Module>;\n  fallback?: ReactNode;\n};\n\nexport type LazyHandle = {\n  preload(): Promise<void>;\n  readonly status: LoadStatus;\n};\n\nexport type LazyResourceErrorProps<Resource = string> = {\n  error: LazyResourceError;\n  retry: () => void;\n  resource: Resource;\n};\n\nexport type LazyResourceErrorComponent<Resource = string> = ComponentType<\n  LazyResourceErrorProps<Resource>\n>;\nexport type LazyResourceLoadingComponent<Resource = string> = ComponentType<{\n  resource: Resource;\n}>;\nexport type LazyResourceStates<Resource = string> = {\n  Error?: LazyResourceErrorComponent<Resource>;\n  Loading?: LazyResourceLoadingComponent<Resource>;\n};\n\ntype ErrorHandlerContext<Context> = [Context] extends [never]\n  ? []\n  : [context: Context];\n\nexport type LazyErrorHandlers<\n  Resource,\n  Custom extends object = {},\n  Context = never,\n> = {\n  [Code in LazyResourceError['code']]?: (\n    props: Custom &\n      Omit<LazyResourceErrorProps<Resource>, 'error'> & {\n        error: LazyResourceErrorMap[Code];\n      },\n    ...context: ErrorHandlerContext<Context>\n  ) => ReactNode;\n} & {\n  fallback?: (\n    props: Custom & LazyResourceErrorProps<Resource>,\n    ...context: ErrorHandlerContext<Context>\n  ) => ReactNode;\n};\n\nexport type CreateLazyErrorComponent<Resource, Context = never> = {\n  <Custom extends object = {}>(\n    render: (\n      props: Custom & LazyResourceErrorProps<Resource>,\n      ...context: ErrorHandlerContext<Context>\n    ) => ReactNode,\n  ): ComponentType<Custom & LazyResourceErrorProps<Resource>>;\n  <Custom extends object = {}>(\n    handlers: LazyErrorHandlers<Resource, Custom, Context>,\n  ): ComponentType<Custom & LazyResourceErrorProps<Resource>>;\n};\n\n/** Internal factory defaults propagated to layouts without publishing metadata. */\nexport const lazyDefaultsSymbol = Symbol('lazyDefaults');\n\nexport const lazyStatesSymbol = Symbol('lazyStates');\n"],"mappings":";;AA2EA,MAAa,qBAAqB,OAAO,cAAc;AAEvD,MAAa,mBAAmB,OAAO,YAAY"}

package/dist/props.cjs

@@ -1,9 +1,11 @@
+const require_layout_configuration_error = require('./errors/layout-configuration-error.cjs');
 
 //#region src/props.ts
 function getIncludedPropBehavior(value) {
 	if (value === null || typeof value !== "object") return null;
-	const required = "required" in value && typeof value.required === "boolean" ? value.required : "visibility" in value ? value.visibility === "required" : void 0;
-	const suppliedVia = "suppliedVia" in value ? value.suppliedVia : "passthrough" in value ? value.passthrough : void 0;
+	if ("visibility" in value || "passthrough" in value) throw new require_layout_configuration_error.LayoutConfigurationError("Include properties visibility and passthrough were removed; use required and suppliedVia.");
+	const required = "required" in value && typeof value.required === "boolean" ? value.required : void 0;
+	const suppliedVia = "suppliedVia" in value ? value.suppliedVia : void 0;
 	if (required === void 0 || suppliedVia !== "component" && suppliedVia !== "config") return null;
 	return {
 		visibility: required ? "required" : "optional",