@notionhq/custom-blocks 0.0.58

package/src/bridge/errors.ts

@@ -0,0 +1,13 @@
+import * as v from "valibot"
+
+export type CustomBlockErrorInfo<TCode extends string = string> = {
+	code: TCode
+	message: string
+	isRetryable: boolean
+}
+
+export const customBlockErrorInfoSchema = v.object({
+	code: v.string(),
+	message: v.string(),
+	isRetryable: v.boolean(),
+})

package/src/bridge/hostState.ts

@@ -0,0 +1,154 @@
+import type { NotionDataSource } from "./dataSources/dataSource.js"
+import type {
+	NotionDataSourcePage,
+	NotionDataSourcePageBridge,
+	NotionDataSourcePageUpdateInput,
+	NotionDataSourcePageUpdateResult,
+} from "./dataSources/dataSourcePage.js"
+import type { NotionDataSourceValue } from "./dataSources/dataSourceValue.js"
+import type { NotionPropertySchema } from "./dataSources/propertySchema.js"
+import type { NotionBlockId } from "./ids.js"
+import type { CustomBlockQueryDataSourceErrorInfo } from "./messages/queryDataSourceResult.js"
+import type { CustomBlockPage, NotionPageId } from "./pages/page.js"
+import type { NotionParent } from "./parent.js"
+import type { NotionTheme } from "./theme.js"
+import type { NotionUser } from "./users/user.js"
+
+export type CustomBlockHostState = UninitializedHostState | InitializedHostState
+
+export type UninitializedHostState = {
+	status: "uninitialized"
+	theme: NotionTheme
+}
+
+export type InitializedHostState = {
+	status: "initialized"
+	theme: NotionTheme
+	blockId: NotionBlockId
+	parent: NotionParent
+	page: CustomBlockPage
+	currentUser: NotionUser
+	dataSources: NotionDataSource[]
+	dataSourceState: Record<string, DataSourceQueryState>
+}
+
+export type DataSourceQueryState = {
+	/** Latest pages from the host as parsed from the bridge. `propertiesByKey` is derived lazily. */
+	items: NotionDataSourcePageBridge[]
+	isLoading: boolean
+	hasMore: boolean
+	error?: CustomBlockQueryDataSourceErrorInfo
+	latestRequestId?: string
+	latestSnapshotId?: string
+	latestLimit?: number
+}
+
+export function createEmptyDataSourceQueryState(): DataSourceQueryState {
+	return {
+		items: [],
+		isLoading: false,
+		hasMore: false,
+	}
+}
+
+/**
+ * Resolved page + schema views for a single data source, keyed by raw property
+ * ID and by user-defined key. Re-derived from `propertyIdsByKey` on every read so
+ * renames don't require a re-query.
+ */
+export type DataSourceQueryView = {
+	items: NotionDataSourcePage[]
+	collectionSchema?: NotionDataSource["collectionSchema"]
+	propertySchemasById: { [propertyId: string]: NotionPropertySchema }
+	propertySchemasByKey: { [key: string]: NotionPropertySchema | undefined }
+	isLoading: boolean
+	hasMore: boolean
+	error?: CustomBlockQueryDataSourceErrorInfo
+}
+
+const EMPTY_QUERY_VIEW: DataSourceQueryView = {
+	items: [],
+	propertySchemasById: {},
+	propertySchemasByKey: {},
+	isLoading: false,
+	hasMore: false,
+}
+
+/**
+ * Per-row callback that resolves property keys against the data source and forwards the
+ * resulting write to the bridge. Injected by callers (typically the SDK singleton in `init.ts`)
+ * so this module stays free of bridge-instance dependencies.
+ */
+export type UpdateDataSourcePageFn = (args: {
+	dataSource: NotionDataSource
+	pageId: NotionPageId
+	input: NotionDataSourcePageUpdateInput
+}) => Promise<NotionDataSourcePageUpdateResult>
+
+export function getDataSourceQueryView(
+	hostState: CustomBlockHostState,
+	key: string,
+	updateDataSourcePage: UpdateDataSourcePageFn,
+): DataSourceQueryView {
+	if (hostState.status !== "initialized") {
+		return EMPTY_QUERY_VIEW
+	}
+
+	const dataSource = hostState.dataSources.find(entry => entry.key === key)
+	const queryState =
+		hostState.dataSourceState[key] ?? createEmptyDataSourceQueryState()
+
+	if (dataSource === undefined) {
+		return {
+			items: [],
+			collectionSchema: undefined,
+			propertySchemasById: {},
+			propertySchemasByKey: {},
+			isLoading: queryState.isLoading,
+			hasMore: queryState.hasMore,
+			error: queryState.error,
+		}
+	}
+
+	const propertyIdsByKey = dataSource.propertyIdsByKey
+	const propertySchemasById = dataSource.propertySchemasById
+
+	const resolvedItems: NotionDataSourcePage[] = queryState.items.map(entry => {
+		const propertiesByKey: {
+			[key: string]: NotionDataSourceValue | undefined
+		} = {}
+		for (const [key, propertyId] of Object.entries(propertyIdsByKey)) {
+			propertiesByKey[key] =
+				propertyId === undefined ? undefined : entry.propertiesById[propertyId]
+		}
+		return {
+			id: entry.id,
+			propertiesById: entry.propertiesById,
+			propertiesByKey,
+			update: input =>
+				updateDataSourcePage({
+					dataSource,
+					pageId: entry.id,
+					input,
+				}),
+		}
+	})
+
+	const propertySchemasByKey: {
+		[key: string]: NotionPropertySchema | undefined
+	} = {}
+	for (const [key, propertyId] of Object.entries(propertyIdsByKey)) {
+		propertySchemasByKey[key] =
+			propertyId === undefined ? undefined : propertySchemasById[propertyId]
+	}
+
+	return {
+		items: resolvedItems,
+		collectionSchema: dataSource.collectionSchema,
+		propertySchemasById,
+		propertySchemasByKey,
+		isLoading: queryState.isLoading,
+		hasMore: queryState.hasMore,
+		error: queryState.error,
+	}
+}

package/src/bridge/ids.ts

@@ -0,0 +1,58 @@
+import * as v from "valibot"
+
+declare const notionDataSourceIdBrand: unique symbol
+declare const notionBlockIdBrand: unique symbol
+declare const notionPageIdBrand: unique symbol
+declare const notionSpaceIdBrand: unique symbol
+
+/**
+ * Branded Notion block ID. Host payloads and SDK APIs use plain strings at runtime,
+ * but the brand keeps block IDs from being accidentally mixed with other IDs in TypeScript.
+ */
+export type NotionBlockId = string & {
+	readonly [notionBlockIdBrand]: "NotionBlockId"
+}
+
+export const notionBlockIdSchema = v.custom<NotionBlockId>(
+	value => typeof value === "string",
+	"Expected a Notion block ID",
+)
+
+/**
+ * Branded Notion data source ID. Host payloads and SDK APIs use plain strings at runtime,
+ * but the brand keeps data source IDs from being accidentally mixed with other IDs in TypeScript.
+ */
+export type NotionDataSourceId = string & {
+	readonly [notionDataSourceIdBrand]: "NotionDataSourceId"
+}
+
+export const notionDataSourceIdSchema = v.custom<NotionDataSourceId>(
+	value => typeof value === "string",
+	"Expected a Notion data source ID",
+)
+
+/**
+ * Branded Notion page ID. Host payloads and SDK APIs use plain strings at runtime,
+ * but the brand keeps page IDs from being accidentally mixed with other IDs in TypeScript.
+ */
+export type NotionPageId = string & {
+	readonly [notionPageIdBrand]: "NotionPageId"
+}
+
+export const notionPageIdSchema = v.custom<NotionPageId>(
+	value => typeof value === "string",
+	"Expected a Notion page ID",
+)
+
+/**
+ * Branded Notion workspace/space ID. Host payloads and SDK APIs use plain strings at runtime,
+ * but the brand keeps space IDs from being accidentally mixed with other IDs in TypeScript.
+ */
+export type NotionSpaceId = string & {
+	readonly [notionSpaceIdBrand]: "NotionSpaceId"
+}
+
+export const notionSpaceIdSchema = v.custom<NotionSpaceId>(
+	value => typeof value === "string",
+	"Expected a Notion space ID",
+)

package/src/bridge/incomingType.ts

@@ -0,0 +1,19 @@
+/**
+ * Reads the `type` field off an inbound bridge message, if any.
+ *
+ * Used by both sides of the bridge after the canonical message schema rejects a payload. We still
+ * want to know what type the sender claimed to be sending so we can (a) avoid NACK loops on
+ * `invalidHostMessage` / `invalidSandboxMessage` and (b) include the type in the failure reason
+ * for debugging.
+ */
+export function readIncomingType(data: unknown): string | undefined {
+	if (
+		typeof data === "object" &&
+		data !== null &&
+		"type" in data &&
+		typeof data.type === "string"
+	) {
+		return data.type
+	}
+	return undefined
+}

package/src/bridge/loadManifest.ts

@@ -0,0 +1,89 @@
+import * as v from "valibot"
+import { type CustomBlockManifest, manifestSchema } from "./manifest.js"
+
+const MANIFEST_URL = "custom_blocks.json"
+
+// The schema accepts any string code. The type lists known codes for
+// autocomplete, with an open string fallback for newer senders.
+export const customBlockReadyErrorCodeSchema = v.string()
+
+export type CustomBlockReadyErrorCode =
+	| "manifest_unavailable"
+	| "manifest_invalid"
+	| (string & {})
+
+export const customBlockReadyErrorSchema = v.object({
+	code: customBlockReadyErrorCodeSchema,
+	message: v.string(),
+})
+
+export type CustomBlockReadyError = v.InferOutput<
+	typeof customBlockReadyErrorSchema
+>
+
+export type ManifestLoadResult =
+	| {
+			manifest: CustomBlockManifest | null
+			error?: undefined
+	  }
+	| {
+			manifest: null
+			error: CustomBlockReadyError
+	  }
+
+/**
+ * Attempts to load a `custom_blocks.json` manifest co-located with the bundle.
+ * A missing manifest means the block has no declared data requirements.
+ * Other failures return a structured error so the host can reject the manifest.
+ * The SDK validates the manifest locally for author feedback; the host still
+ * validates the ready message as the iframe trust boundary.
+ */
+export async function loadManifest(): Promise<ManifestLoadResult> {
+	if (typeof fetch !== "function") {
+		const message = `No fetch API available; cannot load ${MANIFEST_URL}.`
+		console.warn(`[notion-custom-sdk] ${message}`)
+		return {
+			manifest: null,
+			error: { code: "manifest_unavailable", message },
+		}
+	}
+	let response: Response
+	try {
+		response = await fetch(MANIFEST_URL, { credentials: "omit" })
+	} catch (error) {
+		const message = `Could not fetch ${MANIFEST_URL}.`
+		console.warn(`[notion-custom-sdk] ${message}`, error)
+		return {
+			manifest: null,
+			error: { code: "manifest_unavailable", message },
+		}
+	}
+	if (response.status === 404) {
+		const message = `No manifest found at ${MANIFEST_URL} (status ${response.status}).`
+		console.warn(`[notion-custom-sdk] ${message}`)
+		return { manifest: null }
+	}
+	if (!response.ok) {
+		const message = `Could not fetch ${MANIFEST_URL} (status ${response.status}).`
+		console.warn(`[notion-custom-sdk] ${message}`)
+		return {
+			manifest: null,
+			error: { code: "manifest_unavailable", message },
+		}
+	}
+	let json: unknown
+	try {
+		json = await response.json()
+	} catch (error) {
+		const message = `Manifest at ${MANIFEST_URL} was not valid JSON.`
+		console.warn(`[notion-custom-sdk] ${message}`, error)
+		return { manifest: null, error: { code: "manifest_invalid", message } }
+	}
+	const parsed = v.safeParse(manifestSchema, json)
+	if (!parsed.success) {
+		const message = `Manifest at ${MANIFEST_URL} did not match schema.`
+		console.warn(`[notion-custom-sdk] ${message}`, parsed.issues)
+		return { manifest: null, error: { code: "manifest_invalid", message } }
+	}
+	return { manifest: parsed.output }
+}

package/src/bridge/manifest.ts

@@ -0,0 +1,53 @@
+import * as v from "valibot"
+import { notionPropertyTypeSchema } from "./dataSources/propertySchema.js"
+
+/**
+ * User-authored manifest declaring the data sources the custom block expects.
+ * Lives at `custom_blocks.json` in the project root and is forwarded to the host with
+ * the bridge `ready` message so the host can pre-bind data sources, surface
+ * configuration UI, etc. The `notionCustomBlock` Vite plugin from
+ * `@notionhq/custom-blocks/vite` wires the JSON file into the dev server and
+ * the build output.
+ */
+
+/**
+ * Decorative icon attached to a manifest data source. Mirrors the
+ * `emoji` / `external` icon variants the public Notion API uses, so the host
+ * can render a recognizable affordance next to the slot in setup UI.
+ */
+export const manifestIconSchema = v.variant("type", [
+	v.object({
+		type: v.literal("emoji"),
+		emoji: v.string(),
+	}),
+	v.object({
+		type: v.literal("external"),
+		url: v.string(),
+	}),
+])
+
+export type ManifestIcon = v.InferOutput<typeof manifestIconSchema>
+
+export const manifestPropertySchema = v.object({
+	name: v.string(),
+	description: v.optional(v.string()),
+	type: notionPropertyTypeSchema,
+})
+
+export type ManifestProperty = v.InferOutput<typeof manifestPropertySchema>
+
+export const manifestDataSourceSchema = v.object({
+	name: v.string(),
+	description: v.optional(v.string()),
+	icon: v.optional(manifestIconSchema),
+	properties: v.optional(v.record(v.string(), manifestPropertySchema), {}),
+})
+
+export type ManifestDataSource = v.InferOutput<typeof manifestDataSourceSchema>
+
+export const manifestSchema = v.object({
+	version: v.literal(1),
+	dataSources: v.record(v.string(), manifestDataSourceSchema),
+})
+
+export type CustomBlockManifest = v.InferOutput<typeof manifestSchema>

package/src/bridge/messages/createPage.ts

@@ -0,0 +1,67 @@
+import * as v from "valibot"
+import {
+	notionBlockIdSchema,
+	notionDataSourceIdSchema,
+	notionPageIdSchema,
+} from "../ids.js"
+import {
+	notionPageCoverSchema,
+	notionPageIconSchema,
+	notionPagePropertyWriteMapSchema,
+} from "../pages/page.js"
+
+/**
+ * Describes where the newly created page should be inserted.
+ * - `start` / `end` (default): prepend / append to the request's `parent`
+ *   page's children.
+ * - `before` / `after`: insert as a sibling of the anchor block identified by
+ *   `blockId`, using the anchor's own structural parent. The anchor can be
+ *   nested anywhere below the page (inside a toggle, column, callout, etc.).
+ */
+export const notionCreatePagePositionSchema = v.variant("type", [
+	v.object({ type: v.literal("start") }),
+	v.object({ type: v.literal("end") }),
+	v.object({ type: v.literal("before"), blockId: notionBlockIdSchema }),
+	v.object({ type: v.literal("after"), blockId: notionBlockIdSchema }),
+])
+
+export type NotionCreatePagePosition = v.InferOutput<
+	typeof notionCreatePagePositionSchema
+>
+
+/**
+ * Parent accepted by the outbound `createPage` bridge message.
+ *
+ * Mirrors Notion's public API `POST /v1/pages` parent shape: `page_id` for a page-parented child,
+ * `data_source_id` for a database row. `data_source_id` is the internal collection ID.
+ *
+ * The SDK additionally accepts a higher-level `data_source_key` variant that resolves to
+ * `data_source_id` locally, using the `dataSources` mapping.
+ */
+export const createPageParentSchema = v.variant("type", [
+	v.object({ type: v.literal("page_id"), page_id: notionPageIdSchema }),
+	v.object({
+		type: v.literal("data_source_id"),
+		data_source_id: notionDataSourceIdSchema,
+	}),
+])
+
+export type CreatePageMessageParent = v.InferOutput<
+	typeof createPageParentSchema
+>
+
+/**
+ * Message sent by the sandbox to ask the host to create a new page on its behalf.
+ * The payload mirrors Notion's public `POST /v1/pages` API.
+ */
+export const createPageMessageSchema = v.object({
+	type: v.literal("createPage"),
+	requestId: v.string(),
+	parent: createPageParentSchema,
+	properties: notionPagePropertyWriteMapSchema,
+	icon: v.optional(notionPageIconSchema),
+	cover: v.optional(notionPageCoverSchema),
+	position: v.optional(notionCreatePagePositionSchema),
+})
+
+export type CreatePageMessage = v.InferOutput<typeof createPageMessageSchema>

package/src/bridge/messages/createPageResult.ts

@@ -0,0 +1,52 @@
+import * as v from "valibot"
+import type { CustomBlockErrorInfo } from "../errors.js"
+import { notionPageSchema } from "../pages/page.js"
+
+// The schema accepts any string code. The type lists known codes for
+// autocomplete, with an open string fallback for newer senders.
+export const customBlockCreatePageErrorCodeSchema = v.string()
+
+export type CustomBlockCreatePageErrorCode =
+	| "create_page_failed"
+	| "invalid_page_parent"
+	| "page_access_failed"
+	| "collection_access_failed"
+	| "unknown_data_source_key"
+	| "unmapped_data_source"
+	| "unmapped_property"
+	| "property_id_mismatch"
+	| "duplicate_property"
+	| "invalid_property_value"
+	| (string & {})
+
+export type CustomBlockCreatePageErrorInfo =
+	CustomBlockErrorInfo<CustomBlockCreatePageErrorCode>
+
+export const customBlockCreatePageErrorInfoSchema = v.object({
+	code: customBlockCreatePageErrorCodeSchema,
+	message: v.string(),
+	isRetryable: v.boolean(),
+})
+
+/**
+ * Message sent by the host in response to a sandbox `createPage` request.
+ */
+export const createPageResultMessageSchema = v.variant("status", [
+	v.object({
+		type: v.literal("createPageResult"),
+		requestId: v.string(),
+		status: v.literal("success"),
+		/** The newly created page. */
+		page: notionPageSchema,
+	}),
+	v.object({
+		type: v.literal("createPageResult"),
+		requestId: v.string(),
+		status: v.literal("error"),
+		error: customBlockCreatePageErrorInfoSchema,
+	}),
+])
+
+export type CreatePageResultMessage = v.InferOutput<
+	typeof createPageResultMessageSchema
+>

package/src/bridge/messages/currentUserChanged.ts

@@ -0,0 +1,14 @@
+import * as v from "valibot"
+import { notionUserSchema } from "../users/user.js"
+
+/**
+ * Sent by the host when the viewing user's profile changes while the block is mounted.
+ */
+export const currentUserChangedMessageSchema = v.object({
+	type: v.literal("currentUserChanged"),
+	currentUser: notionUserSchema,
+})
+
+export type CurrentUserChangedMessage = v.InferOutput<
+	typeof currentUserChangedMessageSchema
+>

package/src/bridge/messages/dataSourcesChanged.ts

@@ -0,0 +1,18 @@
+import * as v from "valibot"
+import { notionDataSourceBindingsSchema } from "../dataSources/dataSource.js"
+
+/**
+ * Message sent by the host whenever the custom block's data-source mapping changes (e.g. a key is
+ * added, removed, or remapped). The SDK replaces its list of configured data sources but keeps any
+ * in-flight `useDataSource` query state for keys that still exist.
+ */
+export const dataSourcesChangedMessageSchema = v.object({
+	type: v.literal("dataSourcesChanged"),
+	dataSources: v.object({
+		bindings: notionDataSourceBindingsSchema,
+	}),
+})
+
+export type DataSourcesChangedMessage = v.InferOutput<
+	typeof dataSourcesChangedMessageSchema
+>

package/src/bridge/messages/getPage.ts

@@ -0,0 +1,52 @@
+import * as v from "valibot"
+import type { CustomBlockErrorInfo } from "../errors.js"
+import { notionPageIdSchema } from "../ids.js"
+import { notionPageSchema } from "../pages/page.js"
+
+// The schema accepts any string code. The type lists known codes for
+// autocomplete, with an open string fallback for newer senders.
+export const customBlockGetPageErrorCodeSchema = v.string()
+
+export type CustomBlockGetPageErrorCode =
+	| "get_page_failed"
+	| "page_access_failed"
+	| (string & {})
+
+export type CustomBlockGetPageErrorInfo =
+	CustomBlockErrorInfo<CustomBlockGetPageErrorCode>
+
+export const customBlockGetPageErrorInfoSchema = v.object({
+	code: customBlockGetPageErrorCodeSchema,
+	message: v.string(),
+	isRetryable: v.boolean(),
+})
+
+/**
+ * Sandbox -> host: fetch a page by ID.
+ */
+export const getPageMessageSchema = v.object({
+	type: v.literal("getPage"),
+	requestId: v.string(),
+	pageId: notionPageIdSchema,
+})
+
+export type GetPageMessage = v.InferOutput<typeof getPageMessageSchema>
+
+export const getPageResultMessageSchema = v.variant("status", [
+	v.object({
+		type: v.literal("getPageResult"),
+		requestId: v.string(),
+		status: v.literal("success"),
+		page: notionPageSchema,
+	}),
+	v.object({
+		type: v.literal("getPageResult"),
+		requestId: v.string(),
+		status: v.literal("error"),
+		error: customBlockGetPageErrorInfoSchema,
+	}),
+])
+
+export type GetPageResultMessage = v.InferOutput<
+	typeof getPageResultMessageSchema
+>

package/src/bridge/messages/getUser.ts

@@ -0,0 +1,48 @@
+import * as v from "valibot"
+import type { CustomBlockErrorInfo } from "../errors.js"
+import { notionUserSchema } from "../users/user.js"
+
+// The schema accepts any string code. The type lists known codes for
+// autocomplete, with an open string fallback for newer senders.
+export const customBlockGetUserErrorCodeSchema = v.string()
+
+export type CustomBlockGetUserErrorCode = "get_user_failed" | (string & {})
+
+export type CustomBlockGetUserErrorInfo =
+	CustomBlockErrorInfo<CustomBlockGetUserErrorCode>
+
+export const customBlockGetUserErrorInfoSchema = v.object({
+	code: customBlockGetUserErrorCodeSchema,
+	message: v.string(),
+	isRetryable: v.boolean(),
+})
+
+/**
+ * Sandbox -> host: fetch a user by ID.
+ */
+export const getUserMessageSchema = v.object({
+	type: v.literal("getUser"),
+	requestId: v.string(),
+	userId: v.string(),
+})
+
+export type GetUserMessage = v.InferOutput<typeof getUserMessageSchema>
+
+export const getUserResultMessageSchema = v.variant("status", [
+	v.object({
+		type: v.literal("getUserResult"),
+		requestId: v.string(),
+		status: v.literal("success"),
+		user: notionUserSchema,
+	}),
+	v.object({
+		type: v.literal("getUserResult"),
+		requestId: v.string(),
+		status: v.literal("error"),
+		error: customBlockGetUserErrorInfoSchema,
+	}),
+])
+
+export type GetUserResultMessage = v.InferOutput<
+	typeof getUserResultMessageSchema
+>

package/src/bridge/messages/hostToSandbox.ts

@@ -0,0 +1,37 @@
+import * as v from "valibot"
+import { createPageResultMessageSchema } from "./createPageResult.js"
+import { currentUserChangedMessageSchema } from "./currentUserChanged.js"
+import { dataSourcesChangedMessageSchema } from "./dataSourcesChanged.js"
+import { getPageResultMessageSchema } from "./getPage.js"
+import { getUserResultMessageSchema } from "./getUser.js"
+import { initMessageSchema } from "./init.js"
+import { invalidSandboxMessageSchema } from "./invalidSandboxMessage.js"
+import { listUsersResultMessageSchema } from "./listUsers.js"
+import { pageChangedMessageSchema } from "./pageChanged.js"
+import { parentChangedMessageSchema } from "./parentChanged.js"
+import { queryDataSourceResultMessageSchema } from "./queryDataSourceResult.js"
+import { themeChangedMessageSchema } from "./themeChanged.js"
+import { updatePageResultMessageSchema } from "./updatePageResult.js"
+
+/**
+ * Discriminated union of every message the host is allowed to send the sandbox.
+ */
+export const hostToSandboxMessageSchema = v.variant("type", [
+	initMessageSchema,
+	themeChangedMessageSchema,
+	parentChangedMessageSchema,
+	pageChangedMessageSchema,
+	currentUserChangedMessageSchema,
+	dataSourcesChangedMessageSchema,
+	queryDataSourceResultMessageSchema,
+	createPageResultMessageSchema,
+	getPageResultMessageSchema,
+	getUserResultMessageSchema,
+	listUsersResultMessageSchema,
+	updatePageResultMessageSchema,
+	invalidSandboxMessageSchema,
+])
+
+export type HostToSandboxMessage = v.InferOutput<
+	typeof hostToSandboxMessageSchema
+>