@notionhq/custom-blocks 0.0.76 → 0.0.78

package/dist/host/createCustomBlockHost.js

@@ -5,17 +5,27 @@ import { initErrorForFailureReason } from "./lifecycle/initErrors.js";
 import { isValidBridgeProtocolVersion } from "./lifecycle/ready.js";
 import { getInvalidSandboxMessageResponse } from "./messages/invalidSandboxMessage.js";
 import { QuerySubscriptions } from "./queries/querySubscriptions.js";
-const DEFAULT_NO_READY_TIMEOUT_MS = 5000;
+const DEFAULT_NO_CONNECT_TIMEOUT_MS = 5000;
+const DEFAULT_NO_INIT_RESULT_TIMEOUT_MS = 5000;
 const DEFAULT_MIN_BRIDGE_PROTOCOL_VERSION = 2;
 export function createCustomBlockHost(options) {
-    const { iframe, initialState, handlers, onReady, onLog, targetOrigin = "*", minBridgeProtocolVersion = DEFAULT_MIN_BRIDGE_PROTOCOL_VERSION, noReadyTimeoutMs = DEFAULT_NO_READY_TIMEOUT_MS, } = options;
+    const { iframe, initialState, handlers, onConnect, onInitResult, onLog, targetOrigin = "*", minBridgeProtocolVersion = DEFAULT_MIN_BRIDGE_PROTOCOL_VERSION, noConnectTimeoutMs = DEFAULT_NO_CONNECT_TIMEOUT_MS, noInitResultTimeoutMs = DEFAULT_NO_INIT_RESULT_TIMEOUT_MS, } = options;
     let theme = initialState.theme;
     let parent = initialState.parent;
     let page = initialState.page;
     let dataSources = initialState.dataSources;
+    let manifest = initialState.manifest;
     let currentUser = initialState.currentUser;
-    let initStatus = "pending";
-    let noReadyTimeoutId;
+    let initStatus = "waitingForConnect";
+    let noConnectTimeoutId;
+    let noInitResultTimeoutId;
+    let activeInitializationId;
+    let connectedSandbox;
+    let pendingThemeChange = false;
+    let pendingParentChange = false;
+    let pendingPageChange = false;
+    let pendingDataSourcesChange;
+    let pendingCurrentUserChange = false;
     const querySubscriptions = new QuerySubscriptions();
     function emit(direction, payload) {
         onLog?.(direction, payload);
@@ -25,71 +35,116 @@ export function createCustomBlockHost(options) {
         iframe.contentWindow?.postMessage(message, targetOrigin);
     }
     function postQueryDataSourceResult(args) {
-        // TODO(custom-blocks): Update when bumping bridge protocol version to 3.
-        // Protocol v2 sandboxes require the legacy optional-error result shape.
-        const message = {
-            type: "queryDataSourceResult",
-            requestId: args.requestId,
-            snapshotId: args.snapshotId,
-            items: args.response.items,
-            hasMore: args.response.hasMore ?? false,
-            error: args.response.error,
-        };
+        const message = args.response.status === "error"
+            ? {
+                type: "queryDataSourceResult",
+                subscriptionId: args.subscriptionId,
+                status: "error",
+                error: args.response.error,
+            }
+            : {
+                type: "queryDataSourceResult",
+                subscriptionId: args.subscriptionId,
+                status: "success",
+                items: args.response.items,
+                hasMore: args.response.hasMore,
+            };
         post(message);
     }
-    function clearNoReadyTimeout() {
-        if (noReadyTimeoutId !== undefined) {
-            window.clearTimeout(noReadyTimeoutId);
-            noReadyTimeoutId = undefined;
+    function clearNoConnectTimeout() {
+        if (noConnectTimeoutId !== undefined) {
+            window.clearTimeout(noConnectTimeoutId);
+            noConnectTimeoutId = undefined;
         }
     }
-    function resolveDataSourcesPayload(ready) {
-        return typeof dataSources === "function" ? dataSources(ready) : dataSources;
+    function clearNoInitResultTimeout() {
+        if (noInitResultTimeoutId !== undefined) {
+            window.clearTimeout(noInitResultTimeoutId);
+            noInitResultTimeoutId = undefined;
+        }
+    }
+    function resolveDataSourcesPayload(connect) {
+        return typeof dataSources === "function"
+            ? dataSources(connect)
+            : dataSources;
     }
-    function sendInit(ready) {
-        if (initStatus !== "pending") {
+    function sendInit(connect) {
+        if (initStatus !== "waitingForConnect") {
+            return false;
+        }
+        onConnect?.(connect);
+        manifest = connect.manifest ?? initialState.manifest;
+        const resolvedDataSources = resolveDataSourcesPayload(connect);
+        const bindingErrorCode = getBindingErrorCode(manifest, resolvedDataSources);
+        if (bindingErrorCode !== undefined) {
+            sendInitError(connect.initializationId, initErrorForFailureReason(bindingErrorCode));
             return false;
         }
-        initStatus = "success";
-        clearNoReadyTimeout();
+        initStatus = "waitingForInitResult";
+        activeInitializationId = connect.initializationId;
+        clearNoConnectTimeout();
         const message = {
             type: "init",
+            initializationId: connect.initializationId,
             status: "success",
             theme,
             blockId: initialState.blockId,
             parent,
             page,
-            dataSources: resolveDataSourcesPayload(ready),
+            manifest,
+            dataSources: resolvedDataSources,
             currentUser,
         };
         post(message);
+        noInitResultTimeoutId = window.setTimeout(() => {
+            if (initStatus !== "waitingForInitResult") {
+                return;
+            }
+            initStatus = "error";
+            emit("warn", {
+                message: "Sandbox did not send initResult",
+                initializationId: connect.initializationId,
+            });
+        }, noInitResultTimeoutMs);
         return true;
     }
-    function sendInitError(error) {
-        if (initStatus !== "pending") {
+    function sendInitError(initializationId, error) {
+        if (initStatus !== "waitingForConnect") {
             return;
         }
         initStatus = "error";
-        clearNoReadyTimeout();
+        activeInitializationId = initializationId;
+        clearNoConnectTimeout();
         post({
             type: "init",
+            initializationId,
             status: "error",
             error,
         });
     }
     function onIframeLoad() {
-        clearNoReadyTimeout();
-        noReadyTimeoutId = window.setTimeout(() => {
-            const initError = initErrorForFailureReason("no_ready");
-            sendInitError(initError);
-        }, noReadyTimeoutMs);
+        clearNoConnectTimeout();
+        if (initStatus !== "waitingForConnect") {
+            // Only set the timeout if the iframe loaded before the `connect` message was sent.
+            return;
+        }
+        noConnectTimeoutId = window.setTimeout(() => {
+            if (initStatus !== "waitingForConnect") {
+                // Only do anything if the iframe loaded before the `connect` message was sent.
+                return;
+            }
+            initStatus = "error";
+            emit("warn", initErrorForFailureReason("no_connect"));
+        }, noConnectTimeoutMs);
     }
     async function handleQuery(message) {
-        querySubscriptions.track(message);
+        const token = querySubscriptions.track(message);
         const response = await handlers.queryDataSource(message);
+        if (!querySubscriptions.isCurrent(message.subscriptionId, token)) {
+            return;
+        }
         postQueryDataSourceResult({
-            requestId: message.requestId,
-            snapshotId: message.snapshotId,
+            subscriptionId: message.subscriptionId,
             response,
         });
     }
@@ -153,13 +208,13 @@ export function createCustomBlockHost(options) {
         };
         post(result);
     }
-    function handleReady(message) {
+    function handleConnect(message) {
         // Verify the bridge protocol version is valid.
         if (!isValidBridgeProtocolVersion(message.bridgeProtocolVersion)) {
             const initError = initErrorForFailureReason("invalid_protocol_version", {
                 currentBridgeProtocolVersion: message.bridgeProtocolVersion,
             });
-            sendInitError(initError);
+            sendInitError(message.initializationId, initError);
             return;
         }
         if (message.bridgeProtocolVersion < minBridgeProtocolVersion) {
@@ -167,17 +222,62 @@ export function createCustomBlockHost(options) {
                 currentBridgeProtocolVersion: message.bridgeProtocolVersion,
                 minBridgeProtocolVersion,
             });
-            sendInitError(initError);
+            sendInitError(message.initializationId, initError);
             return;
         }
-        // If the sandbox reported an error during `ready`, return it as an `init` error.
+        // If the sandbox reported an error during `connect`, return it as an `init` error.
         if (message.status === "error") {
-            sendInitError(message.error);
+            sendInitError(message.initializationId, message.error);
+            return;
+        }
+        if (!sendInit(message)) {
+            return;
+        }
+        connectedSandbox = message;
+    }
+    /**
+     * Sends any pending host state changes to the sandbox. It is possible for these to change
+     * between when the host sends `init` and when the sandbox responds with `initResult`. The host
+     * does send any pending state changes until hearing back from the sandbox.
+     */
+    function flushPendingHostStateChanges() {
+        if (pendingThemeChange) {
+            pendingThemeChange = false;
+            post({ type: "themeChanged", theme });
+        }
+        if (pendingParentChange) {
+            pendingParentChange = false;
+            post({ type: "parentChanged", parent });
+        }
+        if (pendingPageChange) {
+            pendingPageChange = false;
+            post({ type: "pageChanged", page });
+        }
+        if (pendingDataSourcesChange !== undefined) {
+            const nextDataSources = pendingDataSourcesChange;
+            pendingDataSourcesChange = undefined;
+            post({ type: "dataSourcesChanged", dataSources: nextDataSources });
+        }
+        if (pendingCurrentUserChange) {
+            pendingCurrentUserChange = false;
+            post({ type: "currentUserChanged", currentUser });
+        }
+    }
+    function handleInitResult(message) {
+        if (initStatus !== "waitingForInitResult" ||
+            message.initializationId !== activeInitializationId) {
+            emit("warn", {
+                message: "Ignored stale or unexpected initResult",
+                payload: message,
+            });
             return;
         }
-        if (sendInit(message)) {
-            onReady?.(message);
+        clearNoInitResultTimeout();
+        initStatus = message.status === "success" ? "success" : "error";
+        if (initStatus === "success") {
+            flushPendingHostStateChanges();
         }
+        onInitResult?.(message);
     }
     function onInvalidSandboxMessage(data, issues) {
         emit("warn", {
@@ -186,11 +286,7 @@ export function createCustomBlockHost(options) {
             issues,
         });
         const response = getInvalidSandboxMessageResponse(data);
-        if (initStatus === "pending" && response.incomingType === "ready") {
-            const initError = initErrorForFailureReason("invalid_ready");
-            sendInitError(initError);
-        }
-        else if (response.nack !== undefined) {
+        if (response.nack !== undefined) {
             post(response.nack);
         }
     }
@@ -205,9 +301,21 @@ export function createCustomBlockHost(options) {
         }
         const message = parsed.output;
         emit("in", message);
+        if (message.type !== "connect" &&
+            message.type !== "initResult" &&
+            initStatus !== "success") {
+            emit("warn", {
+                message: `Ignored ${message.type} before initialization completed`,
+                payload: message,
+            });
+            return;
+        }
         switch (message.type) {
-            case "ready":
-                handleReady(message);
+            case "connect":
+                handleConnect(message);
+                return;
+            case "initResult":
+                handleInitResult(message);
                 return;
             case "queryDataSource":
                 void handleQuery(message);
@@ -242,26 +350,60 @@ export function createCustomBlockHost(options) {
         stop() {
             window.removeEventListener("message", onMessage);
             iframe.removeEventListener("load", onIframeLoad);
-            clearNoReadyTimeout();
+            clearNoConnectTimeout();
+            clearNoInitResultTimeout();
+            querySubscriptions.clear();
         },
         post,
         setTheme(nextTheme) {
             theme = nextTheme;
+            if (initStatus !== "success") {
+                if (initStatus === "waitingForInitResult") {
+                    pendingThemeChange = true;
+                }
+                return;
+            }
             const message = { type: "themeChanged", theme };
             post(message);
         },
         setParent(nextParent) {
             parent = nextParent;
+            if (initStatus !== "success") {
+                if (initStatus === "waitingForInitResult") {
+                    pendingParentChange = true;
+                }
+                return;
+            }
             const message = { type: "parentChanged", parent };
             post(message);
         },
         setPage(nextPage) {
             page = nextPage;
+            if (initStatus !== "success") {
+                if (initStatus === "waitingForInitResult") {
+                    pendingPageChange = true;
+                }
+                return;
+            }
             const message = { type: "pageChanged", page };
             post(message);
         },
         setDataSources(nextDataSources) {
+            if (connectedSandbox !== undefined &&
+                getBindingErrorCode(manifest, nextDataSources) !== undefined) {
+                emit("warn", {
+                    message: "Ignored invalid data source bindings update",
+                    payload: nextDataSources,
+                });
+                return;
+            }
             dataSources = nextDataSources;
+            if (initStatus !== "success") {
+                if (initStatus === "waitingForInitResult") {
+                    pendingDataSourcesChange = nextDataSources;
+                }
+                return;
+            }
             const message = {
                 type: "dataSourcesChanged",
                 dataSources: nextDataSources,
@@ -270,22 +412,49 @@ export function createCustomBlockHost(options) {
         },
         setCurrentUser(nextCurrentUser) {
             currentUser = nextCurrentUser;
+            if (initStatus !== "success") {
+                if (initStatus === "waitingForInitResult") {
+                    pendingCurrentUserChange = true;
+                }
+                return;
+            }
             post({ type: "currentUserChanged", currentUser });
         },
         refreshQuery({ dataSourceId, response }) {
-            const refresh = querySubscriptions.resolveRefresh({
+            if (initStatus !== "success") {
+                return;
+            }
+            const refreshes = querySubscriptions.resolveRefreshes({
                 dataSourceId,
                 response,
             });
-            if (refresh.status === "missing") {
+            if (refreshes.length === 0) {
                 emit("warn", `No active query exists for data source "${dataSourceId}"`);
                 return;
             }
-            postQueryDataSourceResult({
-                requestId: refresh.requestId,
-                snapshotId: refresh.snapshotId,
-                response: refresh.response,
-            });
+            for (const refresh of refreshes) {
+                postQueryDataSourceResult(refresh);
+            }
         },
     };
 }
+function getBindingErrorCode(manifest, dataSources) {
+    for (const [dataSourceKey, manifestDataSource] of Object.entries(manifest.dataSources)) {
+        const binding = dataSources.bindings[dataSourceKey];
+        if (binding?.collectionPointer === undefined ||
+            binding.collectionSchema === undefined) {
+            return "missing_data_source_binding";
+        }
+        for (const [propertyKey, manifestProperty] of Object.entries(manifestDataSource.properties ?? {})) {
+            const propertyId = binding.propertyIdsByKey?.[propertyKey];
+            if (propertyId === undefined) {
+                return "missing_property_binding";
+            }
+            if (binding.collectionSchema.propertiesById[propertyId]?.type !==
+                manifestProperty.type) {
+                return "invalid_property_binding";
+            }
+        }
+    }
+    return undefined;
+}

package/dist/host/lifecycle/initErrors.d.ts

@@ -3,7 +3,7 @@ import type { CustomBlockInitErrorCode, CustomBlockInitErrorInfo } from "../../b
  * Returns the error info for a given `init` failure code.
  *
  * `init` handshakes are one-shot: after an `init` error, this host instance will not answer another
- * `ready` message. `isRetryable` means a fresh iframe / `init` attempt could plausibly succeed
+ * `connect` message. `isRetryable` means a fresh iframe / `init` attempt could plausibly succeed
  * without changing block code or host configuration.
  */
 export declare function initErrorForFailureReason(reason: CustomBlockInitErrorCode, data?: {

package/dist/host/lifecycle/initErrors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initErrors.d.ts","sourceRoot":"","sources":["../../../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/host/lifecycle/initErrors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,wBAAwB,EACxB,wBAAwB,EACxB,MAAM,+BAA+B,CAAA;AAKtC;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACxC,MAAM,EAAE,wBAAwB,EAChC,IAAI,GAAE;IACL,wBAAwB,CAAC,EAAE,MAAM,CAAA;IACjC,4BAA4B,CAAC,EAAE,MAAM,CAAA;CAChC,GACJ,wBAAwB,CA6H1B"}
+{"version":3,"file":"initErrors.d.ts","sourceRoot":"","sources":["../../../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/host/lifecycle/initErrors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,wBAAwB,EACxB,wBAAwB,EACxB,MAAM,+BAA+B,CAAA;AAKtC;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACxC,MAAM,EAAE,wBAAwB,EAChC,IAAI,GAAE;IACL,wBAAwB,CAAC,EAAE,MAAM,CAAA;IACjC,4BAA4B,CAAC,EAAE,MAAM,CAAA;CAChC,GACJ,wBAAwB,CA+I1B"}

package/dist/host/lifecycle/initErrors.js

@@ -3,28 +3,28 @@ const UNKNOWN_ERROR_MESSAGE = "Unexpected error while initializing custom block.
  * Returns the error info for a given `init` failure code.
  *
  * `init` handshakes are one-shot: after an `init` error, this host instance will not answer another
- * `ready` message. `isRetryable` means a fresh iframe / `init` attempt could plausibly succeed
+ * `connect` message. `isRetryable` means a fresh iframe / `init` attempt could plausibly succeed
  * without changing block code or host configuration.
  */
 export function initErrorForFailureReason(reason, data = {}) {
     switch (reason) {
-        case "no_ready":
+        case "no_connect":
             return {
                 code: reason,
-                message: "Sandbox did not send a ready message.",
+                message: "Sandbox did not send a connect message.",
                 isRetryable: true,
             };
-        case "invalid_ready":
+        case "invalid_connect":
             return {
                 code: reason,
-                message: "Sandbox sent an invalid ready message.",
-                // The sandbox must be updated to send a valid ready message.
+                message: "Sandbox sent an invalid connect message.",
+                // The sandbox must be updated to send a valid connect message.
                 isRetryable: false,
             };
         case "manifest_unavailable":
             return {
                 code: reason,
-                message: "Sandbox could not load its manifest.",
+                message: "The custom block manifest is unavailable.",
                 isRetryable: true,
             };
         case "manifest_invalid":
@@ -102,6 +102,24 @@ export function initErrorForFailureReason(reason, data = {}) {
                 // a property with a compatible schema.
                 isRetryable: false,
             };
+        case "no_init_result":
+            return {
+                code: reason,
+                message: "Sandbox did not acknowledge initialization.",
+                isRetryable: true,
+            };
+        case "invalid_init_result":
+            return {
+                code: reason,
+                message: "Sandbox sent an invalid initialization result.",
+                isRetryable: false,
+            };
+        case "invalid_init_bindings":
+            return {
+                code: reason,
+                message: "Sandbox rejected the host-provided data source bindings.",
+                isRetryable: false,
+            };
         case "not_in_iframe":
             return {
                 code: reason,

package/dist/host/lifecycle/types.d.ts

@@ -1,23 +1,25 @@
 import type { NotionDataSourceBindings } from "../../bridge/dataSources/dataSource.js";
 import type { NotionBlockId } from "../../bridge/ids.js";
-import type { ReadyMessage } from "../../bridge/messages/ready.js";
+import type { CustomBlockManifest } from "../../bridge/manifest.js";
+import type { ConnectMessage } from "../../bridge/messages/connect.js";
 import type { CustomBlockPage } from "../../bridge/pages/page.js";
 import type { NotionParent } from "../../bridge/parent.js";
 import type { NotionTheme } from "../../bridge/theme.js";
 import type { NotionUser } from "../../bridge/users/user.js";
-export type ReadySuccessMessage = Extract<ReadyMessage, {
+export type ConnectSuccessMessage = Extract<ConnectMessage, {
     status: "success";
 }>;
-export type InitStatus = "pending" | "success" | "error";
+export type InitStatus = "waitingForConnect" | "waitingForInitResult" | "success" | "error";
 export type CustomBlockHostDataSourcesPayload = {
     bindings: NotionDataSourceBindings;
 };
-export type CustomBlockHostInitialDataSources = CustomBlockHostDataSourcesPayload | ((ready: ReadySuccessMessage) => CustomBlockHostDataSourcesPayload);
+export type CustomBlockHostInitialDataSources = CustomBlockHostDataSourcesPayload | ((connect: ConnectSuccessMessage) => CustomBlockHostDataSourcesPayload);
 export type CustomBlockHostInitialState = {
     theme: NotionTheme;
     blockId: NotionBlockId;
     parent: NotionParent;
     page: CustomBlockPage;
+    manifest: CustomBlockManifest;
     dataSources: CustomBlockHostInitialDataSources;
     currentUser: NotionUser;
 };

package/dist/host/lifecycle/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/host/lifecycle/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAA;AACtF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAA;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAE5D,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,YAAY,EAAE;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,CAAC,CAAA;AAE9E,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAA;AAExD,MAAM,MAAM,iCAAiC,GAAG;IAC/C,QAAQ,EAAE,wBAAwB,CAAA;CAClC,CAAA;AAED,MAAM,MAAM,iCAAiC,GAC1C,iCAAiC,GACjC,CAAC,CAAC,KAAK,EAAE,mBAAmB,KAAK,iCAAiC,CAAC,CAAA;AAEtE,MAAM,MAAM,2BAA2B,GAAG;IACzC,KAAK,EAAE,WAAW,CAAA;IAClB,OAAO,EAAE,aAAa,CAAA;IACtB,MAAM,EAAE,YAAY,CAAA;IACpB,IAAI,EAAE,eAAe,CAAA;IACrB,WAAW,EAAE,iCAAiC,CAAA;IAC9C,WAAW,EAAE,UAAU,CAAA;CACvB,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/host/lifecycle/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAA;AACtF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAE5D,MAAM,MAAM,qBAAqB,GAAG,OAAO,CAC1C,cAAc,EACd;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,CACrB,CAAA;AAED,MAAM,MAAM,UAAU,GACnB,mBAAmB,GACnB,sBAAsB,GACtB,SAAS,GACT,OAAO,CAAA;AAEV,MAAM,MAAM,iCAAiC,GAAG;IAC/C,QAAQ,EAAE,wBAAwB,CAAA;CAClC,CAAA;AAED,MAAM,MAAM,iCAAiC,GAC1C,iCAAiC,GACjC,CAAC,CAAC,OAAO,EAAE,qBAAqB,KAAK,iCAAiC,CAAC,CAAA;AAE1E,MAAM,MAAM,2BAA2B,GAAG;IACzC,KAAK,EAAE,WAAW,CAAA;IAClB,OAAO,EAAE,aAAa,CAAA;IACtB,MAAM,EAAE,YAAY,CAAA;IACpB,IAAI,EAAE,eAAe,CAAA;IACrB,QAAQ,EAAE,mBAAmB,CAAA;IAC7B,WAAW,EAAE,iCAAiC,CAAA;IAC9C,WAAW,EAAE,UAAU,CAAA;CACvB,CAAA"}

package/dist/host/messages/invalidSandboxMessage.js

@@ -14,9 +14,6 @@ export function getInvalidSandboxMessageResponse(data) {
     };
 }
 function nackReasonForInvalidSandboxMessage(incomingType) {
-    if (incomingType === "ready") {
-        return "Invalid manifest";
-    }
     if (incomingType !== undefined) {
         return `Unsupported sandbox message of type "${incomingType}"`;
     }

package/dist/host/queries/querySubscriptions.d.ts

@@ -1,20 +1,20 @@
 import type { NotionDataSourceId } from "../../bridge/ids.js";
 import type { QueryDataSourceMessage } from "../../bridge/messages/queryDataSource.js";
 import type { CustomBlockHostQueryDataSourceResult } from "./types.js";
-export type QueryRefreshResult = {
-    status: "success";
-    requestId: string;
-    snapshotId: string;
+export type QueryRefresh = {
+    subscriptionId: string;
     response: CustomBlockHostQueryDataSourceResult;
-} | {
-    status: "missing";
 };
+type QuerySubscriptionToken = object;
 export declare class QuerySubscriptions {
-    private readonly latestByDataSourceId;
-    track(message: QueryDataSourceMessage): void;
-    resolveRefresh(args: {
+    private readonly bySubscriptionId;
+    track(message: QueryDataSourceMessage): QuerySubscriptionToken;
+    isCurrent(subscriptionId: string, token: QuerySubscriptionToken): boolean;
+    resolveRefreshes(args: {
         dataSourceId: NotionDataSourceId;
         response: CustomBlockHostQueryDataSourceResult;
-    }): QueryRefreshResult;
+    }): QueryRefresh[];
+    clear(): void;
 }
+export {};
 //# sourceMappingURL=querySubscriptions.d.ts.map

package/dist/host/queries/querySubscriptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"querySubscriptions.d.ts","sourceRoot":"","sources":["../../../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/host/queries/querySubscriptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAA;AACtF,OAAO,KAAK,EACX,oCAAoC,EAEpC,MAAM,YAAY,CAAA;AAEnB,MAAM,MAAM,kBAAkB,GAC3B;IACA,MAAM,EAAE,SAAS,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,oCAAoC,CAAA;CAC7C,GACD;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,CAAA;AAExB,qBAAa,kBAAkB;IAC9B,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAGlC;IAEH,KAAK,CAAC,OAAO,EAAE,sBAAsB;IAQrC,cAAc,CAAC,IAAI,EAAE;QACpB,YAAY,EAAE,kBAAkB,CAAA;QAChC,QAAQ,EAAE,oCAAoC,CAAA;KAC9C,GAAG,kBAAkB;CAkBtB"}
+{"version":3,"file":"querySubscriptions.d.ts","sourceRoot":"","sources":["../../../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/host/queries/querySubscriptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAA;AACtF,OAAO,KAAK,EAAE,oCAAoC,EAAE,MAAM,YAAY,CAAA;AAEtE,MAAM,MAAM,YAAY,GAAG;IAC1B,cAAc,EAAE,MAAM,CAAA;IACtB,QAAQ,EAAE,oCAAoC,CAAA;CAC9C,CAAA;AAED,KAAK,sBAAsB,GAAG,MAAM,CAAA;AAQpC,qBAAa,kBAAkB;IAC9B,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA4C;IAE7E,KAAK,CAAC,OAAO,EAAE,sBAAsB,GAAG,sBAAsB;IAU9D,SAAS,CAAC,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,sBAAsB,GAAG,OAAO;IAIzE,gBAAgB,CAAC,IAAI,EAAE;QACtB,YAAY,EAAE,kBAAkB,CAAA;QAChC,QAAQ,EAAE,oCAAoC,CAAA;KAC9C,GAAG,YAAY,EAAE;IAelB,KAAK;CAGL"}

package/dist/host/queries/querySubscriptions.js

@@ -1,29 +1,45 @@
 export class QuerySubscriptions {
     constructor() {
-        this.latestByDataSourceId = new Map();
+        this.bySubscriptionId = new Map();
     }
     track(message) {
-        this.latestByDataSourceId.set(message.dataSourceId, {
-            requestId: message.requestId,
-            snapshotId: message.snapshotId,
+        const token = {};
+        this.bySubscriptionId.set(message.subscriptionId, {
+            dataSourceId: message.dataSourceId,
             limit: message.limit,
+            token,
         });
+        return token;
     }
-    resolveRefresh(args) {
-        const queryState = this.latestByDataSourceId.get(args.dataSourceId);
-        if (!queryState) {
-            return { status: "missing" };
+    isCurrent(subscriptionId, token) {
+        return this.bySubscriptionId.get(subscriptionId)?.token === token;
+    }
+    resolveRefreshes(args) {
+        const refreshes = [];
+        for (const [subscriptionId, queryState] of this.bySubscriptionId) {
+            if (queryState.dataSourceId !== args.dataSourceId) {
+                continue;
+            }
+            queryState.token = {};
+            refreshes.push({
+                subscriptionId,
+                response: limitResponse(args.response, queryState.limit),
+            });
         }
-        const items = args.response.items.slice(0, queryState.limit);
-        return {
-            status: "success",
-            requestId: queryState.requestId,
-            snapshotId: queryState.snapshotId,
-            response: {
-                items,
-                hasMore: args.response.hasMore ?? args.response.items.length > items.length,
-                error: args.response.error,
-            },
-        };
+        return refreshes;
+    }
+    clear() {
+        this.bySubscriptionId.clear();
+    }
+}
+function limitResponse(response, limit) {
+    if (response.status === "error") {
+        return response;
     }
+    const items = response.items.slice(0, limit);
+    return {
+        status: "success",
+        items,
+        hasMore: response.hasMore || response.items.length > items.length,
+    };
 }