ncblock 0.0.1

package/dist/bridge/messages/hostToSandbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostToSandbox.d.ts","sourceRoot":"","sources":["../../../bridge/messages/hostToSandbox.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAW5B;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAUrC,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,WAAW,CAC/C,OAAO,0BAA0B,CACjC,CAAA"}

package/dist/bridge/messages/hostToSandbox.js

@@ -0,0 +1,24 @@
+import * as v from "valibot";
+import { contextChangedMessageSchema } from "./contextChanged";
+import { createPageResultMessageSchema } from "./createPageResult";
+import { dataSourcesChangedMessageSchema } from "./dataSourcesChanged";
+import { getPageResultMessageSchema } from "./getPage";
+import { initMessageSchema } from "./init";
+import { invalidSandboxMessageSchema } from "./invalidSandboxMessage";
+import { queryDataSourceResultMessageSchema } from "./queryDataSourceResult";
+import { themeChangedMessageSchema } from "./themeChanged";
+import { updatePageResultMessageSchema } from "./updatePageResult";
+/**
+ * Discriminated union of every message the host is allowed to send the sandbox.
+ */
+export const hostToSandboxMessageSchema = v.variant("type", [
+    initMessageSchema,
+    themeChangedMessageSchema,
+    contextChangedMessageSchema,
+    dataSourcesChangedMessageSchema,
+    queryDataSourceResultMessageSchema,
+    createPageResultMessageSchema,
+    getPageResultMessageSchema,
+    updatePageResultMessageSchema,
+    invalidSandboxMessageSchema,
+]);

package/dist/bridge/messages/init.d.ts

@@ -0,0 +1,169 @@
+import * as v from "valibot";
+/**
+ * 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`, `contextChanged`, `dataSourcesChanged`).
+ */
+export declare const initMessageSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"init", undefined>;
+    readonly theme: v.PicklistSchema<["light", "dark"], undefined>;
+    readonly context: v.ObjectSchema<{
+        readonly customBlockId: v.StringSchema<undefined>;
+        readonly parent: v.ObjectSchema<{
+            readonly id: v.StringSchema<undefined>;
+            readonly type: v.StringSchema<undefined>;
+        }, undefined>;
+        readonly page: v.ObjectSchema<{
+            readonly id: v.StringSchema<undefined>;
+        }, undefined>;
+    }, undefined>;
+    readonly dataSources: v.ObjectSchema<{
+        readonly bindings: v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
+            readonly collectionPointer: v.OptionalSchema<v.ObjectSchema<{
+                readonly id: v.CustomSchema<import("../ids").NotionDataSourceId, v.ErrorMessage<v.CustomIssue> | undefined>;
+                readonly table: v.StringSchema<undefined>;
+                readonly spaceId: v.OptionalSchema<v.CustomSchema<import("../ids").NotionSpaceId, v.ErrorMessage<v.CustomIssue> | undefined>, undefined>;
+            }, undefined>, undefined>;
+            readonly collectionSchema: v.OptionalSchema<v.ObjectSchema<{
+                readonly id: v.OptionalSchema<v.CustomSchema<import("../ids").NotionDataSourceId, v.ErrorMessage<v.CustomIssue> | undefined>, undefined>;
+                readonly propertiesById: v.RecordSchema<v.StringSchema<undefined>, v.VariantSchema<"type", [v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"title", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"rich_text", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"number", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"checkbox", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"url", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"email", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"phone_number", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"select", undefined>;
+                    readonly options: v.ArraySchema<v.ObjectSchema<{
+                        readonly id: v.StringSchema<undefined>;
+                        readonly name: v.StringSchema<undefined>;
+                        readonly color: v.OptionalSchema<v.PicklistSchema<["default", "gray", "brown", "orange", "yellow", "green", "blue", "purple", "pink", "red", "gray_background", "brown_background", "orange_background", "yellow_background", "green_background", "blue_background", "purple_background", "pink_background", "red_background", "default_background"], undefined>, undefined>;
+                        readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    }, undefined>, undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"multi_select", undefined>;
+                    readonly options: v.ArraySchema<v.ObjectSchema<{
+                        readonly id: v.StringSchema<undefined>;
+                        readonly name: v.StringSchema<undefined>;
+                        readonly color: v.OptionalSchema<v.PicklistSchema<["default", "gray", "brown", "orange", "yellow", "green", "blue", "purple", "pink", "red", "gray_background", "brown_background", "orange_background", "yellow_background", "green_background", "blue_background", "purple_background", "pink_background", "red_background", "default_background"], undefined>, undefined>;
+                        readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    }, undefined>, undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"status", undefined>;
+                    readonly options: v.ArraySchema<v.ObjectSchema<{
+                        readonly id: v.StringSchema<undefined>;
+                        readonly name: v.StringSchema<undefined>;
+                        readonly color: v.OptionalSchema<v.PicklistSchema<["default", "gray", "brown", "orange", "yellow", "green", "blue", "purple", "pink", "red", "gray_background", "brown_background", "orange_background", "yellow_background", "green_background", "blue_background", "purple_background", "pink_background", "red_background", "default_background"], undefined>, undefined>;
+                        readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    }, undefined>, undefined>;
+                    readonly groups: v.ArraySchema<v.ObjectSchema<{
+                        readonly id: v.StringSchema<undefined>;
+                        readonly name: v.StringSchema<undefined>;
+                        readonly color: v.OptionalSchema<v.PicklistSchema<["default", "gray", "brown", "orange", "yellow", "green", "blue", "purple", "pink", "red", "gray_background", "brown_background", "orange_background", "yellow_background", "green_background", "blue_background", "purple_background", "pink_background", "red_background", "default_background"], undefined>, undefined>;
+                        readonly option_ids: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                    }, undefined>, undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"date", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"people", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"files", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"unique_id", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"relation", undefined>;
+                    readonly data_source_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly dual_property: v.OptionalSchema<v.ObjectSchema<{
+                        readonly synced_property_id: v.StringSchema<undefined>;
+                        readonly synced_property_name: v.StringSchema<undefined>;
+                    }, undefined>, undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"place", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"formula", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"rollup", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"button", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"verification", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"last_visited_time", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"location", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"created_time", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"last_edited_time", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"created_by", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<"last_edited_by", undefined>;
+                    readonly name: v.StringSchema<undefined>;
+                    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>], undefined>, undefined>;
+            }, undefined>, undefined>;
+            readonly propertyIdsByKey: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.OptionalSchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+export type InitMessage = v.InferOutput<typeof initMessageSchema>;
+//# sourceMappingURL=init.d.ts.map

package/dist/bridge/messages/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../bridge/messages/init.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAK5B;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAO5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/bridge/messages/init.js

@@ -0,0 +1,17 @@
+import * as v from "valibot";
+import { notionCustomBlockContextSchema } from "../context";
+import { notionDataSourceBindingsSchema } from "../dataSources/dataSource";
+import { notionThemeSchema } from "../theme";
+/**
+ * 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`, `contextChanged`, `dataSourcesChanged`).
+ */
+export const initMessageSchema = v.object({
+    type: v.literal("init"),
+    theme: notionThemeSchema,
+    context: notionCustomBlockContextSchema,
+    dataSources: v.object({
+        bindings: notionDataSourceBindingsSchema,
+    }),
+});

package/dist/bridge/messages/invalidHostMessage.d.ts

@@ -0,0 +1,15 @@
+import * as v from "valibot";
+/**
+ * Sent by the sandbox back to the host when an inbound host-to-sandbox message could not be parsed
+ * (unknown `type`, schema mismatch, etc.). The host should never reply to an `invalidHostMessage`
+ * with another bridge error message.
+ */
+export declare const invalidHostMessageSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"invalidHostMessage", undefined>;
+    /**
+     * A human-readable string intended for sandbox-side logging. It has no structured contract.
+     */
+    readonly reason: v.StringSchema<undefined>;
+}, undefined>;
+export type InvalidHostMessage = v.InferOutput<typeof invalidHostMessageSchema>;
+//# sourceMappingURL=invalidHostMessage.d.ts.map

package/dist/bridge/messages/invalidHostMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidHostMessage.d.ts","sourceRoot":"","sources":["../../../bridge/messages/invalidHostMessage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;IAEpC;;OAEG;;aAEF,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAA"}

package/dist/bridge/messages/invalidHostMessage.js

@@ -0,0 +1,13 @@
+import * as v from "valibot";
+/**
+ * Sent by the sandbox back to the host when an inbound host-to-sandbox message could not be parsed
+ * (unknown `type`, schema mismatch, etc.). The host should never reply to an `invalidHostMessage`
+ * with another bridge error message.
+ */
+export const invalidHostMessageSchema = v.object({
+    type: v.literal("invalidHostMessage"),
+    /**
+     * A human-readable string intended for sandbox-side logging. It has no structured contract.
+     */
+    reason: v.string(),
+});

package/dist/bridge/messages/invalidSandboxMessage.d.ts

@@ -0,0 +1,15 @@
+import * as v from "valibot";
+/**
+ * Sent by the host back to the sandbox when an inbound sandbox-to-host message could not be parsed
+ * (unknown `type`, schema mismatch, etc.). The sandbox should never reply to an
+ * `invalidSandboxMessage` with another bridge error message.
+ */
+export declare const invalidSandboxMessageSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"invalidSandboxMessage", undefined>;
+    /**
+     * A human-readable string intended for sandbox-side logging. It has no structured contract.
+     */
+    readonly reason: v.StringSchema<undefined>;
+}, undefined>;
+export type InvalidSandboxMessage = v.InferOutput<typeof invalidSandboxMessageSchema>;
+//# sourceMappingURL=invalidSandboxMessage.d.ts.map

package/dist/bridge/messages/invalidSandboxMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidSandboxMessage.d.ts","sourceRoot":"","sources":["../../../bridge/messages/invalidSandboxMessage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;GAIG;AACH,eAAO,MAAM,2BAA2B;;IAEvC;;OAEG;;aAEF,CAAA;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,WAAW,CAChD,OAAO,2BAA2B,CAClC,CAAA"}

package/dist/bridge/messages/invalidSandboxMessage.js

@@ -0,0 +1,13 @@
+import * as v from "valibot";
+/**
+ * Sent by the host back to the sandbox when an inbound sandbox-to-host message could not be parsed
+ * (unknown `type`, schema mismatch, etc.). The sandbox should never reply to an
+ * `invalidSandboxMessage` with another bridge error message.
+ */
+export const invalidSandboxMessageSchema = v.object({
+    type: v.literal("invalidSandboxMessage"),
+    /**
+     * A human-readable string intended for sandbox-side logging. It has no structured contract.
+     */
+    reason: v.string(),
+});

package/dist/bridge/messages/queryDataSource.d.ts

@@ -0,0 +1,13 @@
+import * as v from "valibot";
+/**
+ * Message sent by the sandbox to ask the host to load (or reload) a data
+ * source with a given page size.
+ */
+export declare const queryDataSourceMessageSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"queryDataSource", undefined>;
+    readonly requestId: v.StringSchema<undefined>;
+    readonly key: v.StringSchema<undefined>;
+    readonly limit: v.NumberSchema<undefined>;
+}, undefined>;
+export type QueryDataSourceMessage = v.InferOutput<typeof queryDataSourceMessageSchema>;
+//# sourceMappingURL=queryDataSource.d.ts.map

package/dist/bridge/messages/queryDataSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryDataSource.d.ts","sourceRoot":"","sources":["../../../bridge/messages/queryDataSource.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;;;aAKvC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CACjD,OAAO,4BAA4B,CACnC,CAAA"}

package/dist/bridge/messages/queryDataSource.js

@@ -0,0 +1,11 @@
+import * as v from "valibot";
+/**
+ * Message sent by the sandbox to ask the host to load (or reload) a data
+ * source with a given page size.
+ */
+export const queryDataSourceMessageSchema = v.object({
+    type: v.literal("queryDataSource"),
+    requestId: v.string(),
+    key: v.string(),
+    limit: v.number(),
+});

package/dist/bridge/messages/queryDataSourceResult.d.ts

@@ -0,0 +1,77 @@
+import * as v from "valibot";
+/**
+ * Message sent by the host to the sandbox in response to a `queryDataSource` request.
+ */
+export declare const queryDataSourceResultMessageSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"queryDataSourceResult", undefined>;
+    readonly requestId: v.StringSchema<undefined>;
+    readonly key: v.StringSchema<undefined>;
+    readonly items: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly propertiesById: v.RecordSchema<v.StringSchema<undefined>, v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.VariantSchema<"type", [v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"date", undefined>;
+            readonly start_date: v.StringSchema<undefined>;
+            readonly reminder: v.OptionalSchema<v.UnionSchema<[v.ObjectSchema<{
+                readonly unit: v.PicklistSchema<["year", "month", "week", "day"], undefined>;
+                readonly value: v.NumberSchema<undefined>;
+                readonly time: v.StringSchema<undefined>;
+                readonly defaultTimeZone: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly unit: v.LiteralSchema<"none", undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"daterange", undefined>;
+            readonly start_date: v.StringSchema<undefined>;
+            readonly end_date: v.StringSchema<undefined>;
+            readonly reminder: v.OptionalSchema<v.UnionSchema<[v.ObjectSchema<{
+                readonly unit: v.PicklistSchema<["year", "month", "week", "day"], undefined>;
+                readonly value: v.NumberSchema<undefined>;
+                readonly time: v.StringSchema<undefined>;
+                readonly defaultTimeZone: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly unit: v.LiteralSchema<"none", undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"datetime", undefined>;
+            readonly start_date: v.StringSchema<undefined>;
+            readonly start_time: v.StringSchema<undefined>;
+            readonly time_zone: v.StringSchema<undefined>;
+            readonly reminder: v.OptionalSchema<v.UnionSchema<[v.UnionSchema<[v.ObjectSchema<{
+                readonly unit: v.PicklistSchema<["year", "month", "week", "day"], undefined>;
+                readonly value: v.NumberSchema<undefined>;
+                readonly time: v.StringSchema<undefined>;
+                readonly defaultTimeZone: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly unit: v.PicklistSchema<["hour", "minute"], undefined>;
+                readonly value: v.NumberSchema<undefined>;
+            }, undefined>], undefined>, v.ObjectSchema<{
+                readonly unit: v.LiteralSchema<"none", undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"datetimerange", undefined>;
+            readonly start_date: v.StringSchema<undefined>;
+            readonly start_time: v.StringSchema<undefined>;
+            readonly end_date: v.StringSchema<undefined>;
+            readonly end_time: v.StringSchema<undefined>;
+            readonly time_zone: v.StringSchema<undefined>;
+            readonly reminder: v.OptionalSchema<v.UnionSchema<[v.UnionSchema<[v.ObjectSchema<{
+                readonly unit: v.PicklistSchema<["year", "month", "week", "day"], undefined>;
+                readonly value: v.NumberSchema<undefined>;
+                readonly time: v.StringSchema<undefined>;
+                readonly defaultTimeZone: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly unit: v.PicklistSchema<["hour", "minute"], undefined>;
+                readonly value: v.NumberSchema<undefined>;
+            }, undefined>], undefined>, v.ObjectSchema<{
+                readonly unit: v.LiteralSchema<"none", undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>], undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.StringSchema<undefined>;
+            readonly table: v.StringSchema<undefined>;
+        }, undefined>, undefined>], undefined>, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly hasMore: v.BooleanSchema<undefined>;
+    readonly error: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type QueryDataSourceResultMessage = v.InferOutput<typeof queryDataSourceResultMessageSchema>;
+//# sourceMappingURL=queryDataSourceResult.d.ts.map

package/dist/bridge/messages/queryDataSourceResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryDataSourceResult.d.ts","sourceRoot":"","sources":["../../../bridge/messages/queryDataSourceResult.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAG5B;;GAEG;AACH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAO7C,CAAA;AAEF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,WAAW,CACvD,OAAO,kCAAkC,CACzC,CAAA"}

package/dist/bridge/messages/queryDataSourceResult.js

@@ -0,0 +1,13 @@
+import * as v from "valibot";
+import { notionDataSourcePageBridgeSchema } from "../dataSources/dataSourcePage";
+/**
+ * Message sent by the host to the sandbox in response to a `queryDataSource` request.
+ */
+export const queryDataSourceResultMessageSchema = v.object({
+    type: v.literal("queryDataSourceResult"),
+    requestId: v.string(),
+    key: v.string(),
+    items: v.array(notionDataSourcePageBridgeSchema),
+    hasMore: v.boolean(),
+    error: v.optional(v.string()),
+});

package/dist/bridge/messages/ready.d.ts

@@ -0,0 +1,41 @@
+import * as v from "valibot";
+/**
+ * First message the sandbox sends after mount, kicking off the bridge handshake. The host replies
+ * with `init`.
+ */
+export declare const readyMessageSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"ready", undefined>;
+    /**
+     * 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.
+     */
+    readonly bridgeProtocolVersion: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    /**
+     * The data sources and settings the custom block expects. A sandbox sends `null` if it has no
+     * manifest-declared data requirements. `null` is used (rather than `undefined`) so the
+     * wire-level distinction between "explicitly no manifest" and "field omitted" survives
+     * `postMessage` serialization and runtime validation on the host.
+     */
+    readonly manifest: v.UnionSchema<[v.ObjectSchema<{
+        readonly version: v.LiteralSchema<1, undefined>;
+        readonly dataSources: v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
+            readonly name: v.StringSchema<undefined>;
+            readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly icon: v.OptionalSchema<v.VariantSchema<"type", [v.ObjectSchema<{
+                readonly type: v.LiteralSchema<"emoji", undefined>;
+                readonly emoji: v.StringSchema<undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<"external", undefined>;
+                readonly url: v.StringSchema<undefined>;
+            }, undefined>], undefined>, undefined>;
+            readonly properties: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
+                readonly name: v.StringSchema<undefined>;
+                readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly type: v.PicklistSchema<readonly ["title", "rich_text", "number", "checkbox", "url", "email", "phone_number", "select", "multi_select", "status", "date", "people", "files", "unique_id", "relation", "place", "formula", "rollup", "button", "verification", "last_visited_time", "location", "created_time", "last_edited_time", "created_by", "last_edited_by"], undefined>;
+            }, undefined>, undefined>, {}>;
+        }, undefined>, undefined>;
+    }, undefined>, v.NullSchema<undefined>], undefined>;
+}, undefined>;
+export type ReadyMessage = v.InferOutput<typeof readyMessageSchema>;
+//# sourceMappingURL=ready.d.ts.map

package/dist/bridge/messages/ready.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ready.d.ts","sourceRoot":"","sources":["../../../bridge/messages/ready.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAG5B;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;IAE9B;;;;OAIG;;IAEH;;;;;OAKG;;;;;;;;;;;;;;;;;;;;aAEF,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/bridge/messages/ready.js

@@ -0,0 +1,22 @@
+import * as v from "valibot";
+import { manifestSchema } from "../manifest";
+/**
+ * First message the sandbox sends after mount, kicking off the bridge handshake. The host replies
+ * with `init`.
+ */
+export const readyMessageSchema = v.object({
+    type: v.literal("ready"),
+    /**
+     * 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.optional(v.number()),
+    /**
+     * The data sources and settings the custom block expects. A sandbox sends `null` if it has no
+     * manifest-declared data requirements. `null` is used (rather than `undefined`) so the
+     * wire-level distinction between "explicitly no manifest" and "field omitted" survives
+     * `postMessage` serialization and runtime validation on the host.
+     */
+    manifest: v.union([manifestSchema, v.null_()]),
+});

package/dist/bridge/messages/resize.d.ts

@@ -0,0 +1,12 @@
+import * as v from "valibot";
+/**
+ * Message sent by the sandbox whenever its measured content height changes, so the host can resize
+ * the surrounding iframe to match. The host is free to clamp the value or ignore it. The sandbox
+ * always reports the most recent measurement.
+ */
+export declare const resizeMessageSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"resize", undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>;
+export type ResizeMessage = v.InferOutput<typeof resizeMessageSchema>;
+//# sourceMappingURL=resize.d.ts.map

package/dist/bridge/messages/resize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize.d.ts","sourceRoot":"","sources":["../../../bridge/messages/resize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;aAG9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/bridge/messages/resize.js

@@ -0,0 +1,10 @@
+import * as v from "valibot";
+/**
+ * Message sent by the sandbox whenever its measured content height changes, so the host can resize
+ * the surrounding iframe to match. The host is free to clamp the value or ignore it. The sandbox
+ * always reports the most recent measurement.
+ */
+export const resizeMessageSchema = v.object({
+    type: v.literal("resize"),
+    height: v.pipe(v.number(), v.finite(), v.minValue(0)),
+});