@persona/layout-editor-remote-module 0.0.0-bootstrap.0 → 0.5.1

package/dist/bridge-host.mjs

@@ -0,0 +1,217 @@
+import { a as assertNotSelfOrigin, i as parseModuleToHostMessage, n as SOURCE, t as PROTOCOL_VERSION } from "./protocol-Dz3ZX59L.mjs";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/bridge/host/buildModuleSrc.ts
+const reservedParams = new Set([
+	"access_token",
+	"environment_id",
+	"locale"
+]);
+const credentialParamPattern = /token|secret|password|authorization|api[_-]?key/i;
+function buildModuleSrc(documentUrl, options = {}) {
+	const url = new URL(documentUrl, "http://remote-module.invalid");
+	for (const [key, value] of Object.entries(options.extraParams ?? {})) {
+		if (reservedParams.has(key) || credentialParamPattern.test(key)) throw new Error(`extraParams contains a reserved or credential-like key: ${key}`);
+		url.searchParams.set(key, value);
+	}
+	if (options.accessToken !== void 0) url.searchParams.set("access_token", options.accessToken);
+	if (options.environmentId !== void 0) url.searchParams.set("environment_id", options.environmentId);
+	if (options.locale !== void 0) url.searchParams.set("locale", options.locale);
+	if (/^[a-z][a-z\d+.-]*:\/\//i.test(documentUrl)) return url.toString();
+	return `${url.pathname}${url.search}${url.hash}`;
+}
+
+//#endregion
+//#region src/bridge/host/createHostBridge.ts
+function createHostBridge({ iframe, moduleOrigin, getData, getContext, resolveDataPath, onHeight, onRenderError, initRetryMs = 250, initRetryTimeoutMs = 1e4 }) {
+	assertNotSelfOrigin(moduleOrigin);
+	if (moduleOrigin === "*") throw new Error("Remote module origin must be explicit");
+	let destroyed = false;
+	let initialized = false;
+	let initRetryTimer;
+	const clearInitRetry = () => {
+		if (initRetryTimer !== void 0) {
+			clearInterval(initRetryTimer);
+			initRetryTimer = void 0;
+		}
+	};
+	const post = (message) => {
+		if (!destroyed) iframe.contentWindow?.postMessage(message, moduleOrigin);
+	};
+	const sendInit = () => {
+		initialized = true;
+		post({
+			source: SOURCE,
+			protocolVersion: PROTOCOL_VERSION,
+			type: "init",
+			data: getData(),
+			context: getContext()
+		});
+	};
+	const startInitRetry = () => {
+		clearInitRetry();
+		sendInit();
+		if (initRetryMs <= 0 || initRetryTimeoutMs <= 0) return;
+		const deadline = Date.now() + initRetryTimeoutMs;
+		initRetryTimer = setInterval(() => {
+			if (Date.now() >= deadline) {
+				clearInitRetry();
+				return;
+			}
+			sendInit();
+		}, initRetryMs);
+	};
+	const sendData = (data, requestId) => {
+		post({
+			source: SOURCE,
+			protocolVersion: PROTOCOL_VERSION,
+			type: "data",
+			...requestId === void 0 ? {} : { requestId },
+			data
+		});
+	};
+	const onLoad = () => {
+		if (!destroyed) startInitRetry();
+	};
+	const onMessage = (event) => {
+		if (destroyed || event.origin !== moduleOrigin || event.source !== iframe.contentWindow) return;
+		const message = parseModuleToHostMessage(event.data);
+		if (!message) return;
+		clearInitRetry();
+		switch (message.type) {
+			case "ready":
+				sendInit();
+				break;
+			case "request-data":
+				sendData(getData(), message.requestId);
+				break;
+			case "set-height":
+				onHeight?.(message.height);
+				break;
+			case "render-error":
+				onRenderError?.(message.message);
+				break;
+			case "resolve-data-path":
+				Promise.resolve().then(() => resolveDataPath(message.dataPath, message.variableMap)).then((result) => {
+					post({
+						source: SOURCE,
+						protocolVersion: PROTOCOL_VERSION,
+						type: "data-path-result",
+						requestId: message.requestId,
+						result: result ?? null
+					});
+				}, (error) => {
+					post({
+						source: SOURCE,
+						protocolVersion: PROTOCOL_VERSION,
+						type: "data-path-result",
+						requestId: message.requestId,
+						error: error instanceof Error ? error.message : String(error)
+					});
+				});
+				break;
+		}
+	};
+	window.addEventListener("message", onMessage);
+	iframe.addEventListener("load", onLoad);
+	return {
+		pushData(data) {
+			if (!destroyed && initialized) sendData(data);
+		},
+		pushContext(context) {
+			if (!destroyed && initialized) post({
+				source: SOURCE,
+				protocolVersion: PROTOCOL_VERSION,
+				type: "context",
+				context
+			});
+		},
+		destroy() {
+			if (destroyed) return;
+			destroyed = true;
+			clearInitRetry();
+			window.removeEventListener("message", onMessage);
+			iframe.removeEventListener("load", onLoad);
+		}
+	};
+}
+
+//#endregion
+//#region src/bridge/host/RemoteModuleFrame.tsx
+function RemoteModuleFrame({ documentUrl, moduleOrigin, accessToken, environmentId, locale, extraParams, title, sandbox, referrerPolicy = "no-referrer", initRetryMs, initRetryTimeoutMs, dynamicHeight = false, heightOffset = 0, minHeight, className, style, data, context, resolveDataPath, onRenderError }) {
+	const iframeRef = useRef(null);
+	const dataRef = useRef(data);
+	const contextRef = useRef(context);
+	const onRenderErrorRef = useRef(onRenderError);
+	const resolveDataPathRef = useRef(resolveDataPath);
+	const bridgeRef = useRef(void 0);
+	const [height, setHeight] = useState();
+	dataRef.current = data;
+	contextRef.current = context;
+	onRenderErrorRef.current = onRenderError;
+	resolveDataPathRef.current = resolveDataPath;
+	const src = useMemo(() => buildModuleSrc(documentUrl, {
+		accessToken,
+		environmentId,
+		locale,
+		extraParams
+	}), [
+		accessToken,
+		documentUrl,
+		environmentId,
+		extraParams,
+		locale
+	]);
+	useEffect(() => {
+		const iframe = iframeRef.current;
+		if (!iframe) return;
+		const bridge = createHostBridge({
+			iframe,
+			moduleOrigin,
+			getData: () => dataRef.current,
+			getContext: () => contextRef.current,
+			resolveDataPath: (...args) => resolveDataPathRef.current(...args),
+			initRetryMs,
+			initRetryTimeoutMs,
+			onHeight: (nextHeight) => {
+				setHeight(nextHeight);
+			},
+			onRenderError: (message) => onRenderErrorRef.current?.(message)
+		});
+		bridgeRef.current = bridge;
+		return () => {
+			bridge.destroy();
+			bridgeRef.current = void 0;
+		};
+	}, [
+		initRetryMs,
+		initRetryTimeoutMs,
+		moduleOrigin,
+		src
+	]);
+	useEffect(() => {
+		bridgeRef.current?.pushData(data);
+	}, [data]);
+	useEffect(() => {
+		bridgeRef.current?.pushContext(context);
+	}, [context]);
+	const computedHeight = dynamicHeight && height !== void 0 ? `${Math.max(height + heightOffset, minHeight ?? 0)}px` : minHeight === void 0 ? "100%" : `${minHeight}px`;
+	return /* @__PURE__ */ jsx("iframe", {
+		ref: iframeRef,
+		src,
+		title,
+		sandbox,
+		referrerPolicy,
+		className,
+		style: {
+			...style,
+			height: computedHeight,
+			width: "100%",
+			border: "none"
+		}
+	}, src);
+}
+
+//#endregion
+export { RemoteModuleFrame };

package/dist/define-C-3P4CFz.d.mts

@@ -0,0 +1,223 @@
+import { z } from "zod";
+
+//#region src/schema.d.ts
+declare const layoutTypeSchema: z.ZodEnum<{
+  account: "account";
+  case: "case";
+  transaction: "transaction";
+}>;
+declare const moduleCategorySchema: z.ZodEnum<{
+  build_your_own: "build_your_own";
+  components: "components";
+  management: "management";
+  related_records: "related_records";
+}>;
+declare const moduleBadgeSchema: z.ZodEnum<{
+  beta: "beta";
+  deprecated: "deprecated";
+  improved: "improved";
+  new: "new";
+}>;
+/**
+ * `code` (a chunk URL, direct-`import()`ed) and `document` (a page URL, host
+ * iframes it instead) are mutually exclusive — a delivery is one or the
+ * other, never both, never neither.
+ */
+declare const remoteDeliverySchema: z.ZodUnion<readonly [z.ZodObject<{
+  code: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  document: z.ZodString;
+}, z.core.$strip>]>;
+declare const remoteModuleRegistrationManifestV1Schema: z.ZodObject<{
+  allowAddingToLayout: z.ZodBoolean;
+  allowDynamicHeight: z.ZodOptional<z.ZodBoolean>;
+  badge: z.ZodOptional<z.ZodEnum<{
+    beta: "beta";
+    deprecated: "deprecated";
+    improved: "improved";
+    new: "new";
+  }>>;
+  category: z.ZodOptional<z.ZodEnum<{
+    build_your_own: "build_your_own";
+    components: "components";
+    management: "management";
+    related_records: "related_records";
+  }>>;
+  configSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  defaultSize: z.ZodRecord<z.ZodEnum<{
+    account: "account";
+    case: "case";
+    transaction: "transaction";
+  }> & z.core.$partial, z.ZodObject<{
+    height: z.ZodNumber;
+    width: z.ZodNumber;
+  }, z.core.$strip>>;
+  descriptionShort: z.ZodString;
+  displayName: z.ZodString;
+  icon: z.ZodOptional<z.ZodString>;
+  internalUsersOnly: z.ZodOptional<z.ZodBoolean>;
+  key: z.ZodString;
+  layouts: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+    account: "account";
+    case: "case";
+    transaction: "transaction";
+  }>>>;
+  manifestVersion: z.ZodLiteral<"v1">;
+  remote: z.ZodObject<{
+    css: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    render: z.ZodUnion<readonly [z.ZodObject<{
+      code: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      document: z.ZodString;
+    }, z.core.$strip>]>;
+  }, z.core.$strip>;
+  uiConfigSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type RemoteModuleRegistrationManifestV1Schema = typeof remoteModuleRegistrationManifestV1Schema;
+//#endregion
+//#region src/types.d.ts
+type Json = boolean | JsonObject | JsonValue[] | null | number | string;
+/**
+ * Loose JSON Schema object. Deliberately not a full JSON Schema type system —
+ * this package only needs to carry what `z.toJSONSchema()` emits for consumers
+ * to validate or render.
+ */
+type JsonSchemaObject = Record<string, unknown>;
+/** Mirrors the host's supported layout values. */
+type LayoutType = z.infer<typeof layoutTypeSchema>;
+/** Mirrors the host's supported module badges. */
+type ModuleBadge = z.infer<typeof moduleBadgeSchema>;
+/** Mirrors the host's module-library categories. */
+type ModuleCategory = z.infer<typeof moduleCategorySchema>;
+/**
+ * Options passed to a remote module's `defaultConfig` export. Narrower than the
+ * host's default-config options; host-internal flags are not exposed to remote
+ * modules.
+ */
+interface RemoteModuleDefaultConfigOptions {
+  layoutType: LayoutType;
+  position?: {
+    x: number;
+    y: number;
+  };
+}
+/** See `RemoteModuleRegistrationManifestV1['remote']['render']`. */
+type RemoteModuleDelivery = z.infer<typeof remoteDeliverySchema>;
+/**
+ * Conventional named exports a `{ code }` delivery's module may provide. All
+ * optional and feature-detected by name — see the "one URL, conventional
+ * named exports" design decision. Rendering/sandboxing `render` is out of
+ * scope for this package; only `defaultConfig` has a concrete consumer here
+ * (the host's default-config loader). Not applicable to a `document`
+ * delivery — nothing is ever imported for those, so none of these exports are
+ * reachable.
+ */
+interface RemoteModuleExports {
+  defaultConfig?: (opts: RemoteModuleDefaultConfigOptions) => {
+    config: Json;
+  };
+  render?: unknown;
+}
+/**
+ * Wire format for a remotely-defined layout module. Must stay
+ * JSON-serializable: no functions, no ReactNode, no zod.
+ *
+ * Producers: `defineLayoutModule()` and this package's Vite plugin.
+ * Consumers: the host application.
+ */
+type RemoteModuleRegistrationManifestV1 = z.infer<typeof remoteModuleRegistrationManifestV1Schema>;
+type JsonObject = {
+  [key: string]: Json;
+};
+type JsonValue = Json;
+//#endregion
+//#region src/define.d.ts
+/**
+ * Authoring input to `defineLayoutModule()`. This is NOT the wire manifest —
+ * it carries a source/page path (`render`, resolved relative to the Vite root)
+ * and a live zod schema (`configSchema`), which
+ * the Vite plugin (./vite.ts) resolves into a `RemoteModuleRegistrationManifestV1`
+ * at build time: a code entry becomes a hashed chunk URL, an html entry
+ * becomes its (possibly `path`-overridden) served URL, and `configSchema`
+ * becomes JSON Schema via `z.toJSONSchema()`.
+ */
+interface LayoutModuleDefinitionInput {
+  /**
+   * Whether the layout editor allows adding new instances of this module to
+   * a layout. Only gates new placements — existing layouts that already
+   * contain the module are unaffected. The host ANDs this with its own
+   * gating, never ORs.
+   */
+  allowAddingToLayout: boolean;
+  /** Whether the module exposes the dynamic-height option in its configuration. */
+  allowDynamicHeight?: boolean;
+  badge?: ModuleBadge;
+  category?: ModuleCategory;
+  /** Authored as zod; converted to JSON Schema by the plugin. */
+  configSchema?: z.ZodType;
+  defaultSize: Partial<Record<LayoutType, {
+    height: number;
+    width: number;
+  }>>;
+  descriptionShort: string;
+  displayName: string;
+  /**
+   * Image path for the module-library tile, origin-relative to the module's
+   * source (e.g. `/assets/icon.svg`). The host shows a generic icon when it's
+   * omitted or fails to load; a cross-origin or non-http(s) URL is rejected and
+   * uses the default icon instead.
+   */
+  icon?: string;
+  internalUsersOnly?: boolean;
+  /** Stable key, unique within this app. Never change after release. */
+  key: string;
+  /** Layout contexts this module supports. Empty or omitted means every layout. */
+  layouts?: LayoutType[];
+  /** How this module's main view is delivered. See `LayoutModuleEntry`. */
+  render: LayoutModuleEntry;
+  /**
+   * RJSF `uiSchema` for the generated config panel — widget choice, field
+   * order, labels. Already plain data (not zod, unlike `configSchema`), so
+   * the plugin passes it through to the manifest unchanged.
+   */
+  uiConfigSchema?: Record<string, unknown>;
+}
+/**
+ * An entry a module's `render` slot points at.
+ * Resolved relative to the Vite root — there's no separate per-module
+ * definition file anymore; modules are configured directly wherever
+ * `personaLayoutModules()` is called (typically vite.config.ts).
+ *
+ * `entry`'s FILE EXTENSION decides delivery kind:
+ *   - `.html` — a `document` delivery: the host iframes it instead of
+ *     importing anything. The plugin ensures Vite actually builds/serves
+ *     this file, detecting whether it's already one of the app's own build
+ *     entries (e.g. its main `index.html`) and doing nothing extra if so —
+ *     only injecting it into the build when it isn't already there.
+ *   - anything else (`.ts`/`.tsx`/`.js`/`.jsx`) — a `code` delivery: built
+ *     into a chunk and executed directly in the host's own React tree.
+ *     Exports are feature-detected by conventional name — see
+ *     `RemoteModuleExports` in types.ts.
+ *
+ * `path` is only meaningful alongside an `.html` entry, for a client-routed
+ * SPA whose `index.html` already renders the whole app: rather than iframing
+ * the SPA's root, this names the LOGICAL route its own router should land on
+ * (e.g. `/embed/runs/1`) — the final `document` URL IS that path, not the
+ * html file's physical output path, since a static/SPA-fallback server
+ * serves the same `index.html` either way. Ignored (and meaningless) for a
+ * non-`.html` entry.
+ */
+interface LayoutModuleEntry {
+  entry: string;
+  path?: string;
+}
+/**
+ * Identity function at runtime — it exists to give authors a typed,
+ * discoverable way to build a `personaLayoutModules({ modules: [...] })`
+ * entry, nothing more. All real work (path resolution, build-graph
+ * injection, schema conversion, manifest emission) happens in the Vite
+ * plugin, not here.
+ */
+declare function defineLayoutModule(input: LayoutModuleDefinitionInput): LayoutModuleDefinitionInput;
+//#endregion
+export { JsonSchemaObject as a, ModuleCategory as c, RemoteModuleExports as d, RemoteModuleRegistrationManifestV1 as f, Json as i, RemoteModuleDefaultConfigOptions as l, remoteModuleRegistrationManifestV1Schema as m, LayoutModuleEntry as n, LayoutType as o, RemoteModuleRegistrationManifestV1Schema as p, defineLayoutModule as r, ModuleBadge as s, LayoutModuleDefinitionInput as t, RemoteModuleDelivery as u };

package/dist/index.d.mts

@@ -0,0 +1,98 @@
+import { a as JsonSchemaObject, c as ModuleCategory, d as RemoteModuleExports, f as RemoteModuleRegistrationManifestV1, i as Json, l as RemoteModuleDefaultConfigOptions, m as remoteModuleRegistrationManifestV1Schema, n as LayoutModuleEntry, o as LayoutType, p as RemoteModuleRegistrationManifestV1Schema, r as defineLayoutModule, s as ModuleBadge, t as LayoutModuleDefinitionInput, u as RemoteModuleDelivery } from "./define-C-3P4CFz.mjs";
+import { z } from "zod";
+
+//#region src/manifest-path.d.ts
+
+/**
+ * Default path (site-root-relative) the manifest document is served from and
+ * written to, when `PersonaLayoutModulesOptions.manifestPath` isn't
+ * overridden. A standalone module (rather than living in vite-plugin.ts, the
+ * one place that actually uses it) so it can also be re-exported from the
+ * runtime-safe `.` entry — a consumer wiring up something like CORS for the
+ * manifest route in its own server, outside of vite.config.ts, needs this
+ * default without pulling in vite/esbuild.
+ */
+declare const DEFAULT_MANIFEST_PATH = "/_layout_modules_manifest.json";
+//#endregion
+//#region src/parse.d.ts
+/**
+ * The document the Vite plugin emits at `manifestPath` (and serves from the
+ * dev server): every module the app declares, under a single `modules` key.
+ */
+interface RemoteModuleManifestDocument {
+  modules: RemoteModuleRegistrationManifestV1[];
+}
+/**
+ * Module keys must be unique within one document — a consumer identifies a
+ * module as `${sourceId}/${key}`, so a duplicate would collide. The plugin
+ * already refuses to build such an app; re-checked here so a hand-written or
+ * tampered manifest can't slip one through.
+ */
+declare const remoteModuleManifestDocumentSchema: z.ZodObject<{
+  modules: z.ZodArray<z.ZodObject<{
+    allowAddingToLayout: z.ZodBoolean;
+    allowDynamicHeight: z.ZodOptional<z.ZodBoolean>;
+    badge: z.ZodOptional<z.ZodEnum<{
+      beta: "beta";
+      deprecated: "deprecated";
+      improved: "improved";
+      new: "new";
+    }>>;
+    category: z.ZodOptional<z.ZodEnum<{
+      build_your_own: "build_your_own";
+      components: "components";
+      management: "management";
+      related_records: "related_records";
+    }>>;
+    configSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    defaultSize: z.ZodRecord<z.ZodEnum<{
+      account: "account";
+      case: "case";
+      transaction: "transaction";
+    }> & z.core.$partial, z.ZodObject<{
+      height: z.ZodNumber;
+      width: z.ZodNumber;
+    }, z.core.$strip>>;
+    descriptionShort: z.ZodString;
+    displayName: z.ZodString;
+    icon: z.ZodOptional<z.ZodString>;
+    internalUsersOnly: z.ZodOptional<z.ZodBoolean>;
+    key: z.ZodString;
+    layouts: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+      account: "account";
+      case: "case";
+      transaction: "transaction";
+    }>>>;
+    manifestVersion: z.ZodLiteral<"v1">;
+    remote: z.ZodObject<{
+      css: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      render: z.ZodUnion<readonly [z.ZodObject<{
+        code: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        document: z.ZodString;
+      }, z.core.$strip>]>;
+    }, z.core.$strip>;
+    uiConfigSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type RemoteModuleManifestParseResult = {
+  data: RemoteModuleManifestDocument;
+  success: true;
+} | {
+  error: RemoteModuleManifestParseError;
+  success: false;
+};
+declare class RemoteModuleManifestParseError extends Error {
+  readonly issues: z.core.$ZodIssue[];
+  constructor(error: z.ZodError);
+}
+/**
+ * Validate the raw JSON of a manifest document (e.g. `await response.json()`)
+ * and return it typed. Throws `RemoteModuleManifestParseError` if the document
+ * is malformed; use `safeParseRemoteModuleManifest` to get a result instead.
+ */
+declare function parseRemoteModuleManifest(json: unknown): RemoteModuleManifestDocument;
+/** Non-throwing variant of `parseRemoteModuleManifest`. */
+declare function safeParseRemoteModuleManifest(json: unknown): RemoteModuleManifestParseResult;
+//#endregion
+export { DEFAULT_MANIFEST_PATH, type Json, type JsonSchemaObject, type LayoutModuleDefinitionInput, type LayoutModuleEntry, type LayoutType, type ModuleBadge, type ModuleCategory, type RemoteModuleDefaultConfigOptions, type RemoteModuleDelivery, type RemoteModuleExports, type RemoteModuleManifestDocument, RemoteModuleManifestParseError, type RemoteModuleManifestParseResult, type RemoteModuleRegistrationManifestV1, type RemoteModuleRegistrationManifestV1Schema, defineLayoutModule, parseRemoteModuleManifest, remoteModuleManifestDocumentSchema, remoteModuleRegistrationManifestV1Schema, safeParseRemoteModuleManifest };

package/dist/index.mjs

@@ -0,0 +1,58 @@
+import { n as DEFAULT_MANIFEST_PATH, r as defineLayoutModule, t as remoteModuleRegistrationManifestV1Schema } from "./schema-Bc3ZwB8y.mjs";
+import { z } from "zod";
+
+//#region src/parse.ts
+/**
+* Module keys must be unique within one document — a consumer identifies a
+* module as `${sourceId}/${key}`, so a duplicate would collide. The plugin
+* already refuses to build such an app; re-checked here so a hand-written or
+* tampered manifest can't slip one through.
+*/
+const remoteModuleManifestDocumentSchema = z.object({ modules: z.array(remoteModuleRegistrationManifestV1Schema) }).superRefine((document, ctx) => {
+	const seen = /* @__PURE__ */ new Set();
+	document.modules.forEach((module, index) => {
+		if (seen.has(module.key)) ctx.addIssue({
+			code: "custom",
+			message: `duplicate module key "${module.key}"`,
+			path: [
+				"modules",
+				index,
+				"key"
+			]
+		});
+		seen.add(module.key);
+	});
+});
+var RemoteModuleManifestParseError = class extends Error {
+	issues;
+	constructor(error) {
+		super(`Invalid remote layout module manifest:\n${z.prettifyError(error)}`);
+		this.name = "RemoteModuleManifestParseError";
+		this.issues = error.issues;
+	}
+};
+/**
+* Validate the raw JSON of a manifest document (e.g. `await response.json()`)
+* and return it typed. Throws `RemoteModuleManifestParseError` if the document
+* is malformed; use `safeParseRemoteModuleManifest` to get a result instead.
+*/
+function parseRemoteModuleManifest(json) {
+	const result = remoteModuleManifestDocumentSchema.safeParse(json);
+	if (!result.success) throw new RemoteModuleManifestParseError(result.error);
+	return result.data;
+}
+/** Non-throwing variant of `parseRemoteModuleManifest`. */
+function safeParseRemoteModuleManifest(json) {
+	const result = remoteModuleManifestDocumentSchema.safeParse(json);
+	if (!result.success) return {
+		error: new RemoteModuleManifestParseError(result.error),
+		success: false
+	};
+	return {
+		data: result.data,
+		success: true
+	};
+}
+
+//#endregion
+export { DEFAULT_MANIFEST_PATH, RemoteModuleManifestParseError, defineLayoutModule, parseRemoteModuleManifest, remoteModuleManifestDocumentSchema, remoteModuleRegistrationManifestV1Schema, safeParseRemoteModuleManifest };