@notionhq/custom-blocks 0.0.77 → 0.0.79

package/src/bridge/SandboxBridge.ts

@@ -32,6 +32,7 @@ import {
 import { readIncomingType } from "./incomingType.js"
 import type { ManifestLoadResult } from "./loadManifest.js"
 import type { CustomBlockManifest } from "./manifest.js"
+import type { ConnectMessage } from "./messages/connect.js"
 import type {
 	CreatePageMessage,
 	CreatePageMessageParent,
@@ -39,12 +40,19 @@ import type {
 import type { CustomBlockCreatePageErrorInfo } from "./messages/createPageResult.js"
 import type { GetUserMessage } from "./messages/getUser.js"
 import { hostToSandboxMessageSchema } from "./messages/hostToSandbox.js"
-import { CustomBlockInitError, type InitMessage } from "./messages/init.js"
+import {
+	CustomBlockInitializationError,
+	type InitMessage,
+	initMessageSchema,
+} from "./messages/init.js"
+import type {
+	CustomBlockInitResultErrorInfo,
+	InitResultMessage,
+} from "./messages/initResult.js"
 import type { InvalidHostMessage } from "./messages/invalidHostMessage.js"
 import type { ListUsersMessage } from "./messages/listUsers.js"
 import type { QueryDataSourceMessage } from "./messages/queryDataSource.js"
 import type { CustomBlockQueryDataSourceErrorInfo } from "./messages/queryDataSourceResult.js"
-import type { ReadyMessage } from "./messages/ready.js"
 import type { ResizeMessage } from "./messages/resize.js"
 import type { UpdatePageMessage } from "./messages/updatePage.js"
 import { PendingRequests } from "./pendingRequests.js"
@@ -55,7 +63,7 @@ import type { NotionUser } from "./users/user.js"
  * single host needs to support multiple custom blocks built with different versions of the bridge
  * protocol. Increment this number any time a breaking change is made to the bridge protocol.
  */
-export const CUSTOM_BLOCK_BRIDGE_PROTOCOL_VERSION = 2
+export const CUSTOM_BLOCK_BRIDGE_PROTOCOL_VERSION = 3
 
 /**
  * A single entry in the bridge message log. Kept intentionally plain so the log
@@ -75,6 +83,7 @@ export class SandboxBridge {
 	private listeners = new Set<() => void>()
 	private messageLog: MessageLogEntry[] = []
 	private messageLogListeners = new Set<() => void>()
+	private nextRequestId = 1
 	private readonly pendingCreatePage = new PendingRequests<CreatePageResult>(
 		"custom-block-create-page",
 	)
@@ -90,20 +99,22 @@ export class SandboxBridge {
 	private readonly pendingUpdatePage = new PendingRequests<UpdatePageResult>(
 		"custom-block-update-page",
 	)
-	private hasSentReady = false
+	private hasSentConnect = false
+	private hasReceivedInit = false
+	private initializationId: string | undefined
 	private latestDataSourceBindings: NotionDataSourceBindings = {}
-	private resolveInit: ((message: InitMessage) => void) | undefined
+	private isMockState = false
+	private resolveInit: (() => void) | undefined
 	private rejectInit: ((reason: Error) => void) | undefined
-	private readonly initMessage: Promise<InitMessage> = new Promise(
+	private readonly initMessage: Promise<void> = new Promise(
 		(resolve, reject) => {
 			this.resolveInit = resolve
 			this.rejectInit = reject
 		},
 	)
-	private manifest: CustomBlockManifest | null = null
 
 	constructor() {
-		// `ready` is sent later by `initCustomBlock` (after the manifest fetch
+		// `connect` is sent later by `initCustomBlock` (after the manifest fetch
 		// resolves). Top-level / no-iframe rejection is handled there too, so
 		// the constructor just attaches the listener.
 		if (typeof window !== "undefined") {
@@ -136,7 +147,7 @@ export class SandboxBridge {
 		return () => this.messageLogListeners.delete(listener)
 	}
 
-	awaitInit(signal?: AbortSignal): Promise<InitMessage> {
+	awaitInit(signal?: AbortSignal): Promise<void> {
 		if (!signal) {
 			return this.initMessage
 		}
@@ -148,9 +159,9 @@ export class SandboxBridge {
 			const onAbort = () => reject(signal.reason)
 			signal.addEventListener("abort", onAbort, { once: true })
 			this.initMessage.then(
-				message => {
+				() => {
 					signal.removeEventListener("abort", onAbort)
-					resolve(message)
+					resolve()
 				},
 				err => {
 					signal.removeEventListener("abort", onAbort)
@@ -160,34 +171,38 @@ export class SandboxBridge {
 		})
 	}
 
-	sendReady(manifestResult: ManifestLoadResult) {
+	sendConnect(manifestResult: ManifestLoadResult) {
 		if (typeof window === "undefined") {
 			return
 		}
-		if (this.hasSentReady) {
-			console.warn("[custom-blocks-sdk] ignoring duplicate ready message")
+		if (this.hasSentConnect) {
+			console.warn("[custom-blocks-sdk] ignoring duplicate connect message")
 			return
 		}
 		const { manifest, error } = manifestResult
-		this.hasSentReady = true
-		this.manifest = manifest
-		const readyMessage: ReadyMessage =
+		this.hasSentConnect = true
+		const initializationId = `custom-block-initialization-${this.nextRequestId}`
+		this.nextRequestId += 1
+		this.initializationId = initializationId
+		const connectMessage: ConnectMessage =
 			error !== undefined
 				? {
-						type: "ready",
+						type: "connect",
+						initializationId,
 						status: "error",
 						bridgeProtocolVersion: CUSTOM_BLOCK_BRIDGE_PROTOCOL_VERSION,
 						sdkVersion: CUSTOM_BLOCKS_SDK_VERSION,
 						error,
 					}
 				: {
-						type: "ready",
+						type: "connect",
+						initializationId,
 						status: "success",
 						bridgeProtocolVersion: CUSTOM_BLOCK_BRIDGE_PROTOCOL_VERSION,
 						sdkVersion: CUSTOM_BLOCKS_SDK_VERSION,
-						manifest,
+						...(manifest !== null ? { manifest } : {}),
 					}
-		this.postToHost(readyMessage)
+		this.postToHost(connectMessage)
 	}
 
 	private postToHost(message: unknown) {
@@ -252,7 +267,18 @@ export class SandboxBridge {
 		// `init` is the only message valid before initialization. Handle it up
 		// front so every later case can assume `status === "initialized"`.
 		if (message.type === "init") {
-			this.applyInit(message)
+			if (message.initializationId !== this.initializationId) {
+				console.warn(
+					`[custom-blocks-sdk] ignoring init for unknown initializationId ${message.initializationId}`,
+				)
+				return
+			}
+			if (this.hasReceivedInit) {
+				console.warn("[custom-blocks-sdk] ignoring duplicate init message")
+				return
+			}
+			this.hasReceivedInit = true
+			this.applyInit(message, true)
 			return
 		}
 
@@ -307,10 +333,12 @@ export class SandboxBridge {
 				const dataSources = reuseDataSourcesForUnchangedBindings({
 					previousDataSources: hostState.dataSources,
 					previousBindings: this.latestDataSourceBindings,
-					nextDataSources: resolveDataSources({
-						manifest: this.manifest,
-						dataSourceBindings: nextBindings,
-					}),
+					nextDataSources: this.isMockState
+						? resolveMockDataSources(nextBindings)
+						: resolveDataSources({
+								manifest: hostState.manifest,
+								dataSourceBindings: nextBindings,
+							}),
 					nextBindings,
 				})
 				this.latestDataSourceBindings = nextBindings
@@ -449,16 +477,6 @@ export class SandboxBridge {
 		return this.hostState
 	}
 
-	/**
-	 * The author-declared manifest loaded from `custom_blocks.json` and forwarded
-	 * to the host in `ready`. `null` when it failed to load/parse and the host
-	 * should reject init via `ready.status: "error"`. Static for the lifetime
-	 * of the sandbox.
-	 */
-	getManifest(): CustomBlockManifest | null {
-		return this.manifest
-	}
-
 	/**
 	 * Apply an `init` payload as if it had arrived from the host. Lets callers
 	 * seed the bridge directly (e.g. the React provider's standalone preview
@@ -466,10 +484,14 @@ export class SandboxBridge {
 	 * of why it's being seeded.
 	 */
 	setMockState(message: InitMessage) {
-		this.applyInit(message)
+		this.isMockState = true
+		this.applyInit(v.parse(initMessageSchema, message), false)
 	}
 
-	private applyInit(message: InitMessage) {
+	private applyInit(message: InitMessage, postResult: boolean) {
+		if (postResult) {
+			this.isMockState = false
+		}
 		if (message.status === "error") {
 			// The host couldn't construct block location for this block (most commonly the parent record
 			// failed to resolve). Surface the failure through the `awaitInit` promise so callers see
@@ -481,7 +503,7 @@ export class SandboxBridge {
 				`[custom-blocks-sdk] host reported init error (${message.error.code}): ${message.error.message}`,
 			)
 			if (this.rejectInit) {
-				this.rejectInit(new CustomBlockInitError(message.error))
+				this.rejectInit(new CustomBlockInitializationError(message.error))
 				this.resolveInit = undefined
 				this.rejectInit = undefined
 			}
@@ -491,10 +513,28 @@ export class SandboxBridge {
 		const { blockId, parent, page } = message
 
 		this.latestDataSourceBindings = message.dataSources.bindings
-		const dataSources = resolveDataSources({
-			manifest: this.manifest,
-			dataSourceBindings: this.latestDataSourceBindings,
-		})
+		const dataSources = postResult
+			? resolveDataSources({
+					manifest: message.manifest,
+					dataSourceBindings: this.latestDataSourceBindings,
+				})
+			: resolveMockDataSources(this.latestDataSourceBindings)
+		const bindingError = getInitBindingError(message.manifest, dataSources)
+		if (postResult && bindingError !== undefined) {
+			const result: InitResultMessage = {
+				type: "initResult",
+				initializationId: message.initializationId,
+				status: "error",
+				error: bindingError,
+			}
+			this.postToHost(result)
+			if (this.rejectInit) {
+				this.rejectInit(new CustomBlockInitializationError(bindingError))
+				this.resolveInit = undefined
+				this.rejectInit = undefined
+			}
+			return
+		}
 		this.hostState = {
 			status: "initialized",
 			theme: message.theme,
@@ -502,15 +542,24 @@ export class SandboxBridge {
 			parent,
 			page,
 			currentUser: message.currentUser,
+			manifest: message.manifest,
 			dataSources,
 			dataSourceState: {},
 		}
 		this.notify()
+		if (postResult) {
+			const result: InitResultMessage = {
+				type: "initResult",
+				initializationId: message.initializationId,
+				status: "success",
+			}
+			this.postToHost(result)
+		}
 		// Resolve the awaitInit promise once. Subsequent `init` messages
 		// (the host shouldn't send these, but be tolerant) update state but
 		// don't re-resolve.
 		if (this.resolveInit) {
-			this.resolveInit(message)
+			this.resolveInit()
 			this.resolveInit = undefined
 			this.rejectInit = undefined
 		}
@@ -892,6 +941,51 @@ function makeDataSourceSubscriptionId(args: { key: string }): string {
 	return `data-source:${encodeURIComponent(key)}`
 }
 
+function getInitBindingError(
+	manifest: CustomBlockManifest,
+	dataSources: NotionDataSource[],
+): CustomBlockInitResultErrorInfo | undefined {
+	for (const [dataSourceKey, manifestDataSource] of Object.entries(
+		manifest.dataSources,
+	)) {
+		const dataSource = dataSources.find(entry => entry.key === dataSourceKey)
+		if (
+			dataSource?.collectionPointer === undefined ||
+			dataSource.collectionSchema === undefined
+		) {
+			return {
+				code: "invalid_init_bindings",
+				message: `Host did not provide a complete binding for data source "${dataSourceKey}".`,
+				isRetryable: false,
+			}
+		}
+		for (const propertyKey of Object.keys(
+			manifestDataSource.properties ?? {},
+		)) {
+			if (dataSource.propertyIdsByKey[propertyKey] === undefined) {
+				return {
+					code: "invalid_init_bindings",
+					message: `Host did not provide a valid binding for property "${dataSourceKey}.${propertyKey}".`,
+					isRetryable: false,
+				}
+			}
+		}
+	}
+	return undefined
+}
+
+function resolveMockDataSources(
+	bindings: NotionDataSourceBindings,
+): NotionDataSource[] {
+	return Object.entries(bindings).map(([key, binding]) => ({
+		key,
+		collectionPointer: binding.collectionPointer,
+		collectionSchema: binding.collectionSchema,
+		propertyIdsByKey: { ...(binding.propertyIdsByKey ?? {}) },
+		propertySchemasById: binding.collectionSchema?.propertiesById ?? {},
+	}))
+}
+
 function formatInvalidHostReason(
 	incomingType: string | undefined,
 	issues: readonly v.BaseIssue<unknown>[],

package/src/bridge/dataSources/resolve.ts

@@ -5,7 +5,7 @@ import type {
 } from "./dataSource.js"
 
 type ResolveDataSourcesArgs = {
-	manifest: CustomBlockManifest | null
+	manifest: CustomBlockManifest
 	dataSourceBindings: NotionDataSourceBindings
 }
 
@@ -13,23 +13,12 @@ type ResolveDataSourcesArgs = {
  * Builds the public {@link NotionDataSource} list the SDK exposes to consumers.
  *
  * Combines the host-supplied bindings (collection pointers + schemas) with the
- * manifest's declared data-source keys. Property mappings are host-owned: the
- * SDK validates the supplied property id against the manifest and live schema,
- * but does not infer a missing mapping.
+ * manifest's declared data-source keys. The host owns every mapping; the SDK
+ * validates supplied IDs but never infers omitted bindings.
  */
 export function resolveDataSources(
 	args: ResolveDataSourcesArgs,
 ): NotionDataSource[] {
-	if (args.manifest === null) {
-		return Object.entries(args.dataSourceBindings).map(([key, binding]) => ({
-			key,
-			collectionPointer: binding.collectionPointer,
-			collectionSchema: binding.collectionSchema,
-			propertyIdsByKey: { ...(binding.propertyIdsByKey ?? {}) },
-			propertySchemasById: binding.collectionSchema?.propertiesById ?? {},
-		}))
-	}
-
 	return Object.entries(args.manifest.dataSources).map(
 		([key, manifestDataSource]) => {
 			const binding = args.dataSourceBindings[key]

package/src/bridge/hostState.ts

@@ -8,6 +8,7 @@ import type {
 import type { NotionDataSourceValue } from "./dataSources/dataSourceValue.js"
 import type { NotionPropertySchema } from "./dataSources/propertySchema.js"
 import type { NotionBlockId } from "./ids.js"
+import type { CustomBlockManifest } from "./manifest.js"
 import type { CustomBlockQueryDataSourceErrorInfo } from "./messages/queryDataSourceResult.js"
 import type { CustomBlockPage, NotionPageId } from "./pages/page.js"
 import type { NotionParent } from "./parent.js"
@@ -28,6 +29,7 @@ export type InitializedHostState = {
 	parent: NotionParent
 	page: CustomBlockPage
 	currentUser: NotionUser
+	manifest: CustomBlockManifest
 	dataSources: NotionDataSource[]
 	dataSourceState: Record<string, DataSourceQueryState>
 }

package/src/bridge/loadManifest.ts

@@ -4,13 +4,13 @@ import { type CustomBlockManifest, manifestSchema } from "./manifest.js"
 
 const MANIFEST_URL = "custom_blocks.json"
 
-export type CustomBlockReadyErrorCode =
+export type CustomBlockConnectErrorCode =
 	| "manifest_unavailable"
 	| "manifest_invalid"
 	| (string & {})
 
-export type CustomBlockReadyError =
-	CustomBlockErrorInfo<CustomBlockReadyErrorCode>
+export type CustomBlockConnectError =
+	CustomBlockErrorInfo<CustomBlockConnectErrorCode>
 
 export type ManifestLoadResult =
 	| {
@@ -19,7 +19,7 @@ export type ManifestLoadResult =
 	  }
 	| {
 			manifest: null
-			error: CustomBlockReadyError
+			error: CustomBlockConnectError
 	  }
 
 /**
@@ -27,7 +27,7 @@ export type ManifestLoadResult =
  * 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.
+ * validates the connect message as the iframe trust boundary.
  */
 export async function loadManifest(): Promise<ManifestLoadResult> {
 	if (typeof fetch !== "function") {
@@ -48,7 +48,7 @@ export async function loadManifest(): Promise<ManifestLoadResult> {
 			manifest: null,
 			// Consider this retryable because it may have just been a network issue. Because `init`
 			// errors are considered terminal, the host should "retry" by reloading the iframe and
-			// sending another `ready` message.
+			// sending another `connect` message.
 			error: { code: "manifest_unavailable", message, isRetryable: true },
 		}
 	}

package/src/bridge/manifest.ts

@@ -3,9 +3,9 @@ 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
+ * Lives at `custom_blocks.json` in the project root. The sandbox may send it in
+ * `connect`, and the host returns the authoritative manifest in `init`. The
+ * `notionCustomBlock` Vite plugin from
  * `@notionhq/custom-blocks/vite` wires the JSON file into the dev server and
  * the build output.
  */

package/src/bridge/messages/connect.ts

@@ -0,0 +1,42 @@
+import * as v from "valibot"
+import { customBlockErrorInfoSchema } from "../errors.js"
+import { manifestSchema } from "../manifest.js"
+
+const connectMessageCommonEntries = {
+	type: v.literal("connect"),
+	initializationId: v.string(),
+	/**
+	 * Used to ensure that the host and client are using the same version of the bridge protocol. A
+	 * single host needs to support multiple custom blocks built with different versions of the bridge
+	 * protocol. Increment this number any time a breaking change is made to the bridge protocol.
+	 */
+	bridgeProtocolVersion: v.number(),
+	/**
+	 * Semver version of the SDK package that sent this connect message. Should only be used for
+	 * analytics purposes. Business logic should compare against `bridgeProtocolVersion` instead.
+	 */
+	sdkVersion: v.string(),
+}
+
+/**
+ * First message the sandbox sends after mount. It identifies the sandbox and starts the bridge
+ * initialization exchange. The host echoes `initializationId` in its `init` response.
+ */
+export const connectMessageSchema = v.variant("status", [
+	v.object({
+		status: v.literal("success"),
+		/**
+		 * The data sources and settings the custom block expects. Hosts may omit
+		 * this when they already have an authoritative manifest.
+		 */
+		manifest: v.optional(manifestSchema),
+		...connectMessageCommonEntries,
+	}),
+	v.object({
+		status: v.literal("error"),
+		error: customBlockErrorInfoSchema,
+		...connectMessageCommonEntries,
+	}),
+])
+
+export type ConnectMessage = v.InferOutput<typeof connectMessageSchema>

package/src/bridge/messages/init.ts

@@ -2,18 +2,18 @@ import * as v from "valibot"
 import { notionDataSourceBindingsSchema } from "../dataSources/dataSource.js"
 import type { CustomBlockErrorCode, CustomBlockErrorInfo } from "../errors.js"
 import { notionBlockIdSchema } from "../ids.js"
+import { manifestSchema } from "../manifest.js"
 import { customBlockPageSchema } from "../pages/page.js"
 import { notionParentSchema } from "../parent.js"
 import { notionThemeSchema } from "../theme.js"
 import { notionUserSchema } from "../users/user.js"
+import type { CustomBlockInitResultErrorCode } from "./initResult.js"
 
 // The schema accepts any string code. The type lists known codes for
 // autocomplete, with an open string fallback for newer senders.
 export const customBlockInitErrorCodeSchema = v.string()
 
 export type CustomBlockInitErrorCode = CustomBlockErrorCode<
-	| "no_ready"
-	| "invalid_ready"
 	| "manifest_unavailable"
 	| "manifest_invalid"
 	| "invalid_protocol_version"
@@ -24,47 +24,60 @@ export type CustomBlockInitErrorCode = CustomBlockErrorCode<
 	| "data_source_unavailable"
 	| "missing_property_binding"
 	| "invalid_property_binding"
-	| "not_in_iframe"
-	| "init_timeout"
 >
 
 export type CustomBlockInitErrorInfo =
 	CustomBlockErrorInfo<CustomBlockInitErrorCode>
 
+/**
+ * Every initialization failure visible to block code. This combines errors
+ * received in `init`, errors the sandbox reports in `initResult`, and failures
+ * detected locally while running `initCustomBlock()`.
+ */
+export type CustomBlockInitializationErrorCode =
+	| CustomBlockInitErrorCode
+	| CustomBlockInitResultErrorCode
+	| CustomBlockErrorCode<"not_in_iframe" | "init_timeout">
+
+export type CustomBlockInitializationErrorInfo =
+	CustomBlockErrorInfo<CustomBlockInitializationErrorCode>
+
 export const customBlockInitErrorInfoSchema = v.object({
 	code: customBlockInitErrorCodeSchema,
 	message: v.string(),
 	isRetryable: v.boolean(),
 })
 
-export class CustomBlockInitError
+export class CustomBlockInitializationError
 	extends Error
 	implements CustomBlockErrorInfo
 {
-	constructor(error: CustomBlockInitErrorInfo) {
+	constructor(error: CustomBlockInitializationErrorInfo) {
 		super(error.message)
-		this.name = "CustomBlockInitError"
+		this.name = "CustomBlockInitializationError"
 		this.code = error.code
 		this.isRetryable = error.isRetryable
 	}
 
-	code: CustomBlockInitErrorCode
+	code: CustomBlockInitializationErrorCode
 	isRetryable: boolean
 }
 
 /**
  * Initialization message sent by the host to the sandbox exactly once, in response to the
- * sandbox's `ready` message. After init, live updates flow through narrower messages
- * (`themeChanged`, `parentChanged`, `pageChanged`, `dataSourcesChanged`).
+ * sandbox's `connect` message. The sandbox echoes `initializationId` in `initResult`. After
+ * successful initialization, live updates flow through narrower messages.
  */
 export const initMessageSchema = v.variant("status", [
 	v.object({
 		type: v.literal("init"),
+		initializationId: v.string(),
 		status: v.literal("success"),
 		theme: notionThemeSchema,
 		blockId: notionBlockIdSchema,
 		parent: notionParentSchema,
 		page: customBlockPageSchema,
+		manifest: manifestSchema,
 		dataSources: v.object({
 			bindings: notionDataSourceBindingsSchema,
 		}),
@@ -72,6 +85,7 @@ export const initMessageSchema = v.variant("status", [
 	}),
 	v.object({
 		type: v.literal("init"),
+		initializationId: v.string(),
 		status: v.literal("error"),
 		error: customBlockInitErrorInfoSchema,
 	}),

package/src/bridge/messages/initResult.ts

@@ -0,0 +1,37 @@
+import * as v from "valibot"
+import type { CustomBlockErrorCode, CustomBlockErrorInfo } from "../errors.js"
+
+// The schema accepts any string code. The type lists known codes for
+// autocomplete, with an open string fallback for newer senders.
+export const customBlockInitResultErrorCodeSchema = v.string()
+
+export type CustomBlockInitResultErrorCode =
+	CustomBlockErrorCode<"invalid_init_bindings">
+
+export type CustomBlockInitResultErrorInfo =
+	CustomBlockErrorInfo<CustomBlockInitResultErrorCode>
+
+export const customBlockInitResultErrorInfoSchema = v.object({
+	code: customBlockInitResultErrorCodeSchema,
+	message: v.string(),
+	isRetryable: v.boolean(),
+})
+
+/**
+ * Acknowledges whether the sandbox successfully applied the host's `init` response.
+ */
+export const initResultMessageSchema = v.variant("status", [
+	v.object({
+		type: v.literal("initResult"),
+		initializationId: v.string(),
+		status: v.literal("success"),
+	}),
+	v.object({
+		type: v.literal("initResult"),
+		initializationId: v.string(),
+		status: v.literal("error"),
+		error: customBlockInitResultErrorInfoSchema,
+	}),
+])
+
+export type InitResultMessage = v.InferOutput<typeof initResultMessageSchema>

package/src/bridge/messages/sandboxToHost.ts

@@ -1,11 +1,12 @@
 import * as v from "valibot"
+import { connectMessageSchema } from "./connect.js"
 import { createPageMessageSchema } from "./createPage.js"
 import { getPageMessageSchema } from "./getPage.js"
 import { getUserMessageSchema } from "./getUser.js"
+import { initResultMessageSchema } from "./initResult.js"
 import { invalidHostMessageSchema } from "./invalidHostMessage.js"
 import { listUsersMessageSchema } from "./listUsers.js"
 import { queryDataSourceMessageSchema } from "./queryDataSource.js"
-import { readyMessageSchema } from "./ready.js"
 import { resizeMessageSchema } from "./resize.js"
 import { updatePageMessageSchema } from "./updatePage.js"
 
@@ -14,7 +15,8 @@ import { updatePageMessageSchema } from "./updatePage.js"
  * inbound traffic from sandboxes without re-implementing validation logic.
  */
 export const sandboxToHostMessageSchema = v.union([
-	readyMessageSchema,
+	connectMessageSchema,
+	initResultMessageSchema,
 	queryDataSourceMessageSchema,
 	createPageMessageSchema,
 	getPageMessageSchema,

package/src/bridge/sandboxClient.ts

@@ -17,7 +17,6 @@ import {
 	getDataSourceQueryView as getDataSourceQueryViewWithBridge,
 } from "./hostState.js"
 import type { ManifestLoadResult } from "./loadManifest.js"
-import type { CustomBlockManifest } from "./manifest.js"
 import type { InitMessage } from "./messages/init.js"
 import { type MessageLogEntry, SandboxBridge } from "./SandboxBridge.js"
 
@@ -26,11 +25,11 @@ export type { MessageLogEntry }
 const bridge = new SandboxBridge()
 
 export const customBlockHost = {
-	sendReady: (manifestResult: ManifestLoadResult) => {
-		bridge.sendReady(manifestResult)
+	sendConnect: (manifestResult: ManifestLoadResult) => {
+		bridge.sendConnect(manifestResult)
 	},
 
-	awaitInit: (signal?: AbortSignal): Promise<InitMessage> => {
+	awaitInit: (signal?: AbortSignal): Promise<void> => {
 		return bridge.awaitInit(signal)
 	},
 
@@ -42,10 +41,6 @@ export const customBlockHost = {
 		return bridge.getHostState()
 	},
 
-	getManifest: (): CustomBlockManifest | null => {
-		return bridge.getManifest()
-	},
-
 	/**
 	 * Apply an `init` payload directly, bypassing the postMessage handshake for
 	 * standalone preview state.