ncblock 0.0.2 → 0.0.4

package/dist/bridge/hostState.d.ts

@@ -0,0 +1,57 @@
+import type { NotionCustomBlockContext } from "./context";
+import type { NotionDataSource } from "./dataSources/dataSource";
+import type { NotionDataSourcePage, NotionDataSourcePageBridge, NotionDataSourcePageUpdateInput, NotionDataSourcePageUpdateResult } from "./dataSources/dataSourcePage";
+import type { NotionPropertySchema } from "./dataSources/propertySchema";
+import type { NotionPageId } from "./pages/page";
+import type { NotionTheme } from "./theme";
+export type CustomBlockHostState = UninitializedHostState | InitializedHostState;
+export type UninitializedHostState = {
+    status: "uninitialized";
+    theme: NotionTheme;
+};
+export type InitializedHostState = {
+    status: "initialized";
+    theme: NotionTheme;
+    context: NotionCustomBlockContext;
+    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?: string;
+    latestRequestId?: string;
+};
+export declare function createEmptyDataSourceQueryState(): DataSourceQueryState;
+/**
+ * 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?: string;
+};
+/**
+ * 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 declare function getDataSourceQueryView(hostState: CustomBlockHostState, key: string, updateDataSourcePage: UpdateDataSourcePageFn): DataSourceQueryView;
+//# sourceMappingURL=hostState.d.ts.map

package/dist/bridge/hostState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostState.d.ts","sourceRoot":"","sources":["../../bridge/hostState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAA;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAChE,OAAO,KAAK,EACX,oBAAoB,EACpB,0BAA0B,EAC1B,+BAA+B,EAC/B,gCAAgC,EAChC,MAAM,8BAA8B,CAAA;AAErC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,MAAM,MAAM,oBAAoB,GAAG,sBAAsB,GAAG,oBAAoB,CAAA;AAEhF,MAAM,MAAM,sBAAsB,GAAG;IACpC,MAAM,EAAE,eAAe,CAAA;IACvB,KAAK,EAAE,WAAW,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IAClC,MAAM,EAAE,aAAa,CAAA;IACrB,KAAK,EAAE,WAAW,CAAA;IAClB,OAAO,EAAE,wBAAwB,CAAA;IACjC,WAAW,EAAE,gBAAgB,EAAE,CAAA;IAC/B,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAA;CACrD,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IAClC,iGAAiG;IACjG,KAAK,EAAE,0BAA0B,EAAE,CAAA;IACnC,SAAS,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,eAAe,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,wBAAgB,+BAA+B,IAAI,oBAAoB,CAMtE;AAED;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG;IACjC,KAAK,EAAE,oBAAoB,EAAE,CAAA;IAC7B,gBAAgB,CAAC,EAAE,gBAAgB,CAAC,kBAAkB,CAAC,CAAA;IACvD,mBAAmB,EAAE;QAAE,CAAC,UAAU,EAAE,MAAM,GAAG,oBAAoB,CAAA;KAAE,CAAA;IACnE,oBAAoB,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAAA;KAAE,CAAA;IACzE,SAAS,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAUD;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,EAAE;IAC3C,UAAU,EAAE,gBAAgB,CAAA;IAC5B,MAAM,EAAE,YAAY,CAAA;IACpB,KAAK,EAAE,+BAA+B,CAAA;CACtC,KAAK,OAAO,CAAC,gCAAgC,CAAC,CAAA;AAE/C,wBAAgB,sBAAsB,CACrC,SAAS,EAAE,oBAAoB,EAC/B,GAAG,EAAE,MAAM,EACX,oBAAoB,EAAE,sBAAsB,GAC1C,mBAAmB,CA8DrB"}

package/dist/bridge/hostState.js

@@ -0,0 +1,65 @@
+export function createEmptyDataSourceQueryState() {
+    return {
+        items: [],
+        isLoading: false,
+        hasMore: false,
+    };
+}
+const EMPTY_QUERY_VIEW = {
+    items: [],
+    propertySchemasById: {},
+    propertySchemasByKey: {},
+    isLoading: false,
+    hasMore: false,
+};
+export function getDataSourceQueryView(hostState, key, updateDataSourcePage) {
+    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 = queryState.items.map(entry => {
+        const propertiesByKey = {};
+        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 = {};
+    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/dist/bridge/loadManifest.d.ts

@@ -0,0 +1,9 @@
+import { type CustomBlockManifest } from "./manifest";
+/**
+ * Attempts to load a `custom_blocks.json` manifest co-located with the bundle. Treats
+ * any non-200 response as "no manifest". Warns on every failure path —
+ * templates are expected to ship a manifest, so a missing one is worth
+ * surfacing.
+ */
+export declare function loadManifest(): Promise<CustomBlockManifest | null>;
+//# sourceMappingURL=loadManifest.d.ts.map

package/dist/bridge/loadManifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadManifest.d.ts","sourceRoot":"","sources":["../../bridge/loadManifest.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,mBAAmB,EAAkB,MAAM,YAAY,CAAA;AAIrE;;;;;GAKG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CA0CxE"}

package/dist/bridge/loadManifest.js

@@ -0,0 +1,41 @@
+import * as v from "valibot";
+import { manifestSchema } from "./manifest";
+const MANIFEST_URL = "custom_blocks.json";
+/**
+ * Attempts to load a `custom_blocks.json` manifest co-located with the bundle. Treats
+ * any non-200 response as "no manifest". Warns on every failure path —
+ * templates are expected to ship a manifest, so a missing one is worth
+ * surfacing.
+ */
+export async function loadManifest() {
+    if (typeof fetch !== "function") {
+        console.warn(`[notion-custom-sdk] no \`fetch\` available; cannot load ${MANIFEST_URL}`);
+        return null;
+    }
+    let response;
+    try {
+        response = await fetch(MANIFEST_URL, { credentials: "omit" });
+    }
+    catch (error) {
+        console.warn(`[notion-custom-sdk] no manifest fetched from ${MANIFEST_URL}`, error);
+        return null;
+    }
+    if (!response.ok) {
+        console.warn(`[notion-custom-sdk] no manifest at ${MANIFEST_URL} (status ${response.status})`);
+        return null;
+    }
+    let json;
+    try {
+        json = await response.json();
+    }
+    catch (error) {
+        console.warn(`[notion-custom-sdk] manifest at ${MANIFEST_URL} was not valid JSON`, error);
+        return null;
+    }
+    const parsed = v.safeParse(manifestSchema, json);
+    if (!parsed.success) {
+        console.warn(`[notion-custom-sdk] manifest at ${MANIFEST_URL} did not match schema`, parsed.issues);
+        return null;
+    }
+    return parsed.output;
+}

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

@@ -0,0 +1,32 @@
+import * as v from "valibot";
+/**
+ * Sandbox -> host: fetch a user by ID.
+ */
+export declare const getUserMessageSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"getUser", undefined>;
+    readonly requestId: v.StringSchema<undefined>;
+    readonly userId: v.StringSchema<undefined>;
+}, undefined>;
+export type GetUserMessage = v.InferOutput<typeof getUserMessageSchema>;
+export declare const getUserResultMessageSchema: v.VariantSchema<"status", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"getUserResult", undefined>;
+    readonly requestId: v.StringSchema<undefined>;
+    readonly status: v.LiteralSchema<"success", undefined>;
+    readonly user: v.ObjectSchema<{
+        readonly object: v.LiteralSchema<"user", undefined>;
+        readonly id: v.StringSchema<undefined>;
+        readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly avatar_url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly type: v.LiteralSchema<"person", undefined>;
+        readonly person: v.ObjectSchema<{
+            readonly email: v.StringSchema<undefined>;
+        }, undefined>;
+    }, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"getUserResult", undefined>;
+    readonly requestId: v.StringSchema<undefined>;
+    readonly status: v.LiteralSchema<"error", undefined>;
+    readonly error: v.StringSchema<undefined>;
+}, undefined>], undefined>;
+export type GetUserResultMessage = v.InferOutput<typeof getUserResultMessageSchema>;
+//# sourceMappingURL=getUser.d.ts.map

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

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

package/dist/bridge/messages/getUser.js

@@ -0,0 +1,24 @@
+import * as v from "valibot";
+import { notionUserSchema } from "../users/user";
+/**
+ * Sandbox -> host: fetch a user by ID.
+ */
+export const getUserMessageSchema = v.object({
+    type: v.literal("getUser"),
+    requestId: v.string(),
+    userId: v.string(),
+});
+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: v.string(),
+    }),
+]);

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

@@ -776,6 +776,51 @@ export declare const hostToSandboxMessageSchema: v.VariantSchema<"type", [v.Obje
     readonly requestId: v.StringSchema<undefined>;
     readonly status: v.LiteralSchema<"error", undefined>;
     readonly error: v.StringSchema<undefined>;
+}, undefined>], undefined>, v.VariantSchema<"status", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"getUserResult", undefined>;
+    readonly requestId: v.StringSchema<undefined>;
+    readonly status: v.LiteralSchema<"success", undefined>;
+    readonly user: v.ObjectSchema<{
+        readonly object: v.LiteralSchema<"user", undefined>;
+        readonly id: v.StringSchema<undefined>;
+        readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly avatar_url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly type: v.LiteralSchema<"person", undefined>;
+        readonly person: v.ObjectSchema<{
+            readonly email: v.StringSchema<undefined>;
+        }, undefined>;
+    }, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"getUserResult", undefined>;
+    readonly requestId: v.StringSchema<undefined>;
+    readonly status: v.LiteralSchema<"error", undefined>;
+    readonly error: v.StringSchema<undefined>;
+}, undefined>], undefined>, v.VariantSchema<"status", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"listUsersResult", undefined>;
+    readonly requestId: v.StringSchema<undefined>;
+    readonly status: v.LiteralSchema<"success", undefined>;
+    readonly list: v.ObjectSchema<{
+        readonly object: v.LiteralSchema<"list", undefined>;
+        readonly results: v.ArraySchema<v.ObjectSchema<{
+            readonly object: v.LiteralSchema<"user", undefined>;
+            readonly id: v.StringSchema<undefined>;
+            readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly avatar_url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly type: v.LiteralSchema<"person", undefined>;
+            readonly person: v.ObjectSchema<{
+                readonly email: v.StringSchema<undefined>;
+            }, undefined>;
+        }, undefined>, undefined>;
+        readonly next_cursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly has_more: v.BooleanSchema<undefined>;
+        readonly type: v.LiteralSchema<"user", undefined>;
+        readonly user: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+    }, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"listUsersResult", undefined>;
+    readonly requestId: v.StringSchema<undefined>;
+    readonly status: v.LiteralSchema<"error", undefined>;
+    readonly error: v.StringSchema<undefined>;
 }, undefined>], undefined>, v.VariantSchema<"status", [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"updatePageResult", undefined>;
     readonly requestId: v.StringSchema<undefined>;

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

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

package/dist/bridge/messages/hostToSandbox.js

@@ -3,8 +3,10 @@ import { contextChangedMessageSchema } from "./contextChanged";
 import { createPageResultMessageSchema } from "./createPageResult";
 import { dataSourcesChangedMessageSchema } from "./dataSourcesChanged";
 import { getPageResultMessageSchema } from "./getPage";
+import { getUserResultMessageSchema } from "./getUser";
 import { initMessageSchema } from "./init";
 import { invalidSandboxMessageSchema } from "./invalidSandboxMessage";
+import { listUsersResultMessageSchema } from "./listUsers";
 import { queryDataSourceResultMessageSchema } from "./queryDataSourceResult";
 import { themeChangedMessageSchema } from "./themeChanged";
 import { updatePageResultMessageSchema } from "./updatePageResult";
@@ -19,6 +21,8 @@ export const hostToSandboxMessageSchema = v.variant("type", [
     queryDataSourceResultMessageSchema,
     createPageResultMessageSchema,
     getPageResultMessageSchema,
+    getUserResultMessageSchema,
+    listUsersResultMessageSchema,
     updatePageResultMessageSchema,
     invalidSandboxMessageSchema,
 ]);

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

@@ -0,0 +1,40 @@
+import * as v from "valibot";
+/**
+ * Sandbox -> host: list users visible in the custom block's workspace.
+ */
+export declare const listUsersMessageSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"listUsers", undefined>;
+    readonly requestId: v.StringSchema<undefined>;
+    readonly startCursor: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly pageSize: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+}, undefined>;
+export type ListUsersMessage = v.InferOutput<typeof listUsersMessageSchema>;
+export declare const listUsersResultMessageSchema: v.VariantSchema<"status", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"listUsersResult", undefined>;
+    readonly requestId: v.StringSchema<undefined>;
+    readonly status: v.LiteralSchema<"success", undefined>;
+    readonly list: v.ObjectSchema<{
+        readonly object: v.LiteralSchema<"list", undefined>;
+        readonly results: v.ArraySchema<v.ObjectSchema<{
+            readonly object: v.LiteralSchema<"user", undefined>;
+            readonly id: v.StringSchema<undefined>;
+            readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly avatar_url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly type: v.LiteralSchema<"person", undefined>;
+            readonly person: v.ObjectSchema<{
+                readonly email: v.StringSchema<undefined>;
+            }, undefined>;
+        }, undefined>, undefined>;
+        readonly next_cursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly has_more: v.BooleanSchema<undefined>;
+        readonly type: v.LiteralSchema<"user", undefined>;
+        readonly user: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+    }, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"listUsersResult", undefined>;
+    readonly requestId: v.StringSchema<undefined>;
+    readonly status: v.LiteralSchema<"error", undefined>;
+    readonly error: v.StringSchema<undefined>;
+}, undefined>], undefined>;
+export type ListUsersResultMessage = v.InferOutput<typeof listUsersResultMessageSchema>;
+//# sourceMappingURL=listUsers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"listUsers.d.ts","sourceRoot":"","sources":["../../../bridge/messages/listUsers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAG5B;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;aAKjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;0BAavC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CACjD,OAAO,4BAA4B,CACnC,CAAA"}

package/dist/bridge/messages/listUsers.js

@@ -0,0 +1,25 @@
+import * as v from "valibot";
+import { notionUserListSchema } from "../users/user";
+/**
+ * Sandbox -> host: list users visible in the custom block's workspace.
+ */
+export const listUsersMessageSchema = v.object({
+    type: v.literal("listUsers"),
+    requestId: v.string(),
+    startCursor: v.optional(v.string()),
+    pageSize: v.optional(v.number()),
+});
+export const listUsersResultMessageSchema = v.variant("status", [
+    v.object({
+        type: v.literal("listUsersResult"),
+        requestId: v.string(),
+        status: v.literal("success"),
+        list: notionUserListSchema,
+    }),
+    v.object({
+        type: v.literal("listUsersResult"),
+        requestId: v.string(),
+        status: v.literal("error"),
+        error: v.string(),
+    }),
+]);

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

@@ -214,6 +214,15 @@ export declare const sandboxToHostMessageSchema: v.VariantSchema<"type", [v.Obje
     readonly type: v.LiteralSchema<"getPage", undefined>;
     readonly requestId: v.StringSchema<undefined>;
     readonly pageId: v.StringSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"getUser", undefined>;
+    readonly requestId: v.StringSchema<undefined>;
+    readonly userId: v.StringSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"listUsers", undefined>;
+    readonly requestId: v.StringSchema<undefined>;
+    readonly startCursor: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly pageSize: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly type: v.LiteralSchema<"updatePage", undefined>;
     readonly requestId: v.StringSchema<undefined>;

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

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

package/dist/bridge/messages/sandboxToHost.js

@@ -1,7 +1,9 @@
 import * as v from "valibot";
 import { createPageMessageSchema } from "./createPage";
 import { getPageMessageSchema } from "./getPage";
+import { getUserMessageSchema } from "./getUser";
 import { invalidHostMessageSchema } from "./invalidHostMessage";
+import { listUsersMessageSchema } from "./listUsers";
 import { queryDataSourceMessageSchema } from "./queryDataSource";
 import { readyMessageSchema } from "./ready";
 import { resizeMessageSchema } from "./resize";
@@ -15,6 +17,8 @@ export const sandboxToHostMessageSchema = v.variant("type", [
     queryDataSourceMessageSchema,
     createPageMessageSchema,
     getPageMessageSchema,
+    getUserMessageSchema,
+    listUsersMessageSchema,
     updatePageMessageSchema,
     resizeMessageSchema,
     invalidHostMessageSchema,

package/dist/bridge/sandboxClient.d.ts

@@ -0,0 +1,46 @@
+import type { CreatePageInput, CreatePageResult, GetPageResult, GetUserResult, ListUsersInput, ListUsersResult, NotionPageId, NotionUserId, UpdatePageInput, UpdatePageResult } from "../types";
+import { type CustomBlockHostState, type DataSourceQueryView } from "./hostState";
+import type { CustomBlockManifest } from "./manifest";
+import type { InitMessage } from "./messages/init";
+export declare function sendCustomBlockReady(manifest: CustomBlockManifest | null): void;
+export declare function awaitCustomBlockInit(signal?: AbortSignal): Promise<InitMessage>;
+export declare function subscribeToCustomBlockHost(listener: () => void): () => boolean;
+export declare function getCustomBlockHostState(): CustomBlockHostState;
+export declare function queryCustomBlockDataSource(key: string, limit: number): void;
+/**
+ * Apply an `init` payload to the bridge directly, bypassing the postMessage
+ * handshake. Used by the React provider when it needs to seed placeholder
+ * state (e.g. the standalone preview fallback when not embedded in Notion).
+ * The bridge applies the payload through the same code path as a real host.
+ */
+export declare function setMockCustomBlockState(message: InitMessage): void;
+export declare function postCustomBlockResize(height: number): void;
+export declare function getUser(userId: NotionUserId): Promise<GetUserResult>;
+export declare function listUsers(input?: ListUsersInput): Promise<ListUsersResult>;
+/**
+ * Resolves the host state for a given data-source key into the public {@link DataSourceQueryView},
+ * baking in the singleton bridge so per-row `update` calls flow through it.
+ */
+export declare function getDataSourceQueryView(hostState: CustomBlockHostState, key: string): DataSourceQueryView;
+/**
+ * Page-related SDK APIs exposed under `sdk.pages.*`.
+ */
+export declare const pages: {
+    /**
+     * Creates a new Notion page.
+     */
+    create(input: CreatePageInput): Promise<CreatePageResult>;
+    /**
+     * Fetches a page by id.
+     */
+    get(pageId: NotionPageId): Promise<GetPageResult>;
+    /**
+     * Updates an existing page.
+     */
+    update(input: UpdatePageInput): Promise<UpdatePageResult>;
+    /**
+     * Soft-delete a page by archiving it.
+     */
+    delete(pageId: NotionPageId): Promise<UpdatePageResult>;
+};
+//# sourceMappingURL=sandboxClient.d.ts.map

package/dist/bridge/sandboxClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandboxClient.d.ts","sourceRoot":"","sources":["../../bridge/sandboxClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,cAAc,EACd,eAAe,EACf,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,gBAAgB,EAChB,MAAM,UAAU,CAAA;AACjB,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EAExB,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAKlD,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI,QAExE;AAED,wBAAgB,oBAAoB,CACnC,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,WAAW,CAAC,CAEtB;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,IAAI,iBAE9D;AAED,wBAAgB,uBAAuB,IAAI,oBAAoB,CAE9D;AAED,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAEpE;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,WAAW,QAE3D;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,QAEnD;AAED,wBAAgB,OAAO,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC,CAEpE;AAED,wBAAgB,SAAS,CAAC,KAAK,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC,CAE1E;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACrC,SAAS,EAAE,oBAAoB,EAC/B,GAAG,EAAE,MAAM,GACT,mBAAmB,CAIrB;AAED;;GAEG;AACH,eAAO,MAAM,KAAK;IACjB;;OAEG;kBACW,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAIzD;;OAEG;gBACS,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IAIjD;;OAEG;kBACW,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAIzD;;OAEG;mBACY,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAGvD,CAAA"}

package/dist/bridge/sandboxClient.js

@@ -0,0 +1,72 @@
+import { getDataSourceQueryView as getDataSourceQueryViewWithBridge, } from "./hostState";
+import { SandboxBridge } from "./SandboxBridge";
+const bridge = new SandboxBridge();
+export function sendCustomBlockReady(manifest) {
+    bridge.sendReady(manifest);
+}
+export function awaitCustomBlockInit(signal) {
+    return bridge.awaitInit(signal);
+}
+export function subscribeToCustomBlockHost(listener) {
+    return bridge.subscribe(listener);
+}
+export function getCustomBlockHostState() {
+    return bridge.getHostState();
+}
+export function queryCustomBlockDataSource(key, limit) {
+    bridge.queryDataSource(key, limit);
+}
+/**
+ * Apply an `init` payload to the bridge directly, bypassing the postMessage
+ * handshake. Used by the React provider when it needs to seed placeholder
+ * state (e.g. the standalone preview fallback when not embedded in Notion).
+ * The bridge applies the payload through the same code path as a real host.
+ */
+export function setMockCustomBlockState(message) {
+    bridge.setMockState(message);
+}
+export function postCustomBlockResize(height) {
+    bridge.postResize(height);
+}
+export function getUser(userId) {
+    return bridge.getUser(userId);
+}
+export function listUsers(input) {
+    return bridge.listUsers(input);
+}
+/**
+ * Resolves the host state for a given data-source key into the public {@link DataSourceQueryView},
+ * baking in the singleton bridge so per-row `update` calls flow through it.
+ */
+export function getDataSourceQueryView(hostState, key) {
+    return getDataSourceQueryViewWithBridge(hostState, key, args => bridge.updateDataSourcePage(args));
+}
+/**
+ * Page-related SDK APIs exposed under `sdk.pages.*`.
+ */
+export const pages = {
+    /**
+     * Creates a new Notion page.
+     */
+    create(input) {
+        return bridge.createPage(input);
+    },
+    /**
+     * Fetches a page by id.
+     */
+    get(pageId) {
+        return bridge.getPage(pageId);
+    },
+    /**
+     * Updates an existing page.
+     */
+    update(input) {
+        return bridge.updatePage(input);
+    },
+    /**
+     * Soft-delete a page by archiving it.
+     */
+    delete(pageId) {
+        return bridge.updatePage({ pageId, archived: true });
+    },
+};

package/dist/bridge/users/user.d.ts

@@ -0,0 +1,36 @@
+import * as v from "valibot";
+declare const notionUserIdBrand: unique symbol;
+export type NotionUserId = string & {
+    readonly [notionUserIdBrand]: "NotionUserId";
+};
+export declare const notionUserSchema: v.ObjectSchema<{
+    readonly object: v.LiteralSchema<"user", undefined>;
+    readonly id: v.StringSchema<undefined>;
+    readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly avatar_url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly type: v.LiteralSchema<"person", undefined>;
+    readonly person: v.ObjectSchema<{
+        readonly email: v.StringSchema<undefined>;
+    }, undefined>;
+}, undefined>;
+export type NotionUser = v.InferOutput<typeof notionUserSchema>;
+export declare const notionUserListSchema: v.ObjectSchema<{
+    readonly object: v.LiteralSchema<"list", undefined>;
+    readonly results: v.ArraySchema<v.ObjectSchema<{
+        readonly object: v.LiteralSchema<"user", undefined>;
+        readonly id: v.StringSchema<undefined>;
+        readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly avatar_url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly type: v.LiteralSchema<"person", undefined>;
+        readonly person: v.ObjectSchema<{
+            readonly email: v.StringSchema<undefined>;
+        }, undefined>;
+    }, undefined>, undefined>;
+    readonly next_cursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly has_more: v.BooleanSchema<undefined>;
+    readonly type: v.LiteralSchema<"user", undefined>;
+    readonly user: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+}, undefined>;
+export type NotionUserList = v.InferOutput<typeof notionUserListSchema>;
+export {};
+//# sourceMappingURL=user.d.ts.map

package/dist/bridge/users/user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../bridge/users/user.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,OAAO,CAAC,MAAM,iBAAiB,EAAE,OAAO,MAAM,CAAA;AAE9C,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG;IACnC,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,cAAc,CAAA;CAC5C,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;aAS3B,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE/D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;aAO/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/bridge/users/user.js

@@ -0,0 +1,19 @@
+import * as v from "valibot";
+export const notionUserSchema = v.object({
+    object: v.literal("user"),
+    id: v.string(),
+    name: v.optional(v.string()),
+    avatar_url: v.nullable(v.string()),
+    type: v.literal("person"),
+    person: v.object({
+        email: v.string(),
+    }),
+});
+export const notionUserListSchema = v.object({
+    object: v.literal("list"),
+    results: v.array(notionUserSchema),
+    next_cursor: v.nullable(v.string()),
+    has_more: v.boolean(),
+    type: v.literal("user"),
+    user: v.record(v.string(), v.unknown()),
+});

package/dist/index.d.ts

@@ -19,9 +19,10 @@ export type { NotionDataSourceId, NotionSpaceId } from "./bridge/ids";
 export type { CustomBlockManifest, ManifestDataSource, ManifestIcon, ManifestProperty, } from "./bridge/manifest";
 export type { NotionCreatePagePosition } from "./bridge/messages/createPage";
 export type { NotionPage, NotionPageCover, NotionPageIcon, NotionPageId, NotionPageParent, NotionPagePropertyInputMap, NotionPagePropertyInputValue, NotionPagePropertyValue, NotionPagePropertyWriteMap, } from "./bridge/pages/page";
+export { pages } from "./bridge/sandboxClient";
 export type { NotionTheme } from "./bridge/theme";
-export { type CustomBlockInitial, type InitCustomBlockOptions, initCustomBlock, NotInIframeError, } from "./notion";
-export { pages } from "./pages";
+export { type CustomBlockInitial, type InitCustomBlockOptions, initCustomBlock, NotInIframeError, } from "./init";
 export { NotionCustomBlock, type NotionCustomBlockProps, type UseCustomBlockInitResult, useCustomBlockAutoResize, useCustomBlockContext, useCustomBlockInit, useDataSource, useDataSourceDefinitions, useTheme, } from "./react";
 export * from "./types";
+export { users } from "./users";
 //# sourceMappingURL=index.d.ts.map