@notionhq/custom-blocks 0.0.61 → 0.0.63

package/HOST.md

@@ -66,7 +66,7 @@ The host replies with exactly one `init`, which has two statuses. On success it
 
 ```ts
 // host → sandbox
-{ type: "init", status: "success", theme, blockId, parent, page: { id }, currentUser, dataSources: { bindings } }
+{ type: "init", status: "success", theme, blockId, parent, page: { id, parent }, currentUser, dataSources: { bindings } }
 ```
 
 On failure it carries `error: { code, message, isRetryable }` (`CustomBlockInitErrorInfo` / `customBlockInitErrorInfoSchema`, with `code` drawn from `CustomBlockInitErrorCode` / `customBlockInitErrorCodeSchema`). The SDK surfaces this as a `CustomBlockInitError`:
@@ -82,7 +82,7 @@ After `init`, narrower messages update live state without re-running the handsha
 // host → sandbox, any time after init
 { type: "themeChanged", theme }
 { type: "parentChanged", parent }
-{ type: "pageChanged", page: { id } }
+{ type: "pageChanged", page: { id, parent } }
 { type: "dataSourcesChanged", dataSources: { bindings } }
 ```
 
@@ -112,7 +112,7 @@ Host implementers can use the API-specific aliases and schemas when shaping outb
 
 Types:
 
-- `CustomBlockPage` — the current page slice carried in `init.page` and `pageChanged`.
+- `CustomBlockPage` — the current page slice carried in `init.page` and `pageChanged`: the containing page's `id` plus its own `parent` (a `NotionParent`), so the sandbox can tell a freestanding page from a database row. Hosts must re-send `pageChanged` when either field changes, including when the containing page moves without its ID changing.
 - `NotionDataSourceBinding` — a single binding (collection pointer + schema + property mapping).
 - `NotionDataSourceBindings` — keyed-by-semantic-key map of bindings, the shape carried in `init.dataSources` and `dataSourcesChanged`.
 - `NotionDataSourcePageBridge` — wire shape for a single page (raw property IDs in `propertiesById`). The SDK derives the consumer-facing `NotionDataSourcePage` from it.
@@ -134,7 +134,7 @@ Messages sent from the sandbox to the host. Parse `window` `message` events with
 
 | Wire type            | Type / schema                                             | Behavior                                                                                                                                                                                                                                |
 | -------------------- | --------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ready`              | `ReadyMessage` / `readyMessageSchema`                     | One-shot handshake; carries `bridgeProtocolVersion`, `sdkVersion`, and the manifest.                                                                                                                                                     |
+| `ready`              | `ReadyMessage` / `readyMessageSchema`                     | One-shot handshake; carries `bridgeProtocolVersion`, `sdkVersion`, and the manifest.                                                                                                                                                    |
 | `queryDataSource`    | `QueryDataSourceMessage` / `queryDataSourceMessageSchema` | `requestId`-keyed request for the current rows in a raw `dataSourceId`. `snapshotId` names the SDK result slot to update, so later refreshes for the same `useDataSource` call replace the same snapshot instead of creating a new one. |
 | `createPage`         | `CreatePageMessage` / `createPageMessageSchema`           | `requestId`-keyed page creation; parent is `page_id` or `data_source_id`.                                                                                                                                                               |
 | `getPage`            | `GetPageMessage` / `getPageMessageSchema`                 | `requestId`-keyed page fetch by page id.                                                                                                                                                                                                |

package/bin/notion-custom-blocks/build.js

@@ -0,0 +1,187 @@
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { packDirToTarGz } from "./tar.js";
+export const BUILD_OUTPUT_SENTINEL = "<__notion_custom_block__>";
+export const BUILD_OUTPUT_SENTINEL_CLOSE = "</__notion_custom_block__>";
+const WORKER_ENTRY = "dist/index.js";
+/**
+ * Build every `_tag: "custom_block"` view declared by the worker.
+ *
+ * Imports the worker bundle (`<cwd>/dist/index.js`), reads its runtime manifest,
+ * and runs the command specified (default `npm run build`)
+ */
+export async function buildCustomBlocks(args) {
+    const projectRoot = args.cwd ?? process.cwd();
+    const entryPath = path.resolve(projectRoot, WORKER_ENTRY);
+    const outDir = path.resolve(args.out);
+    const blocks = await readCustomBlocks(entryPath);
+    if (blocks.length === 0) {
+        return { blocks: [] };
+    }
+    const built = [];
+    for (const block of blocks) {
+        const bundleDir = path.join(outDir, block.key);
+        buildCustomBlock({ block, projectRoot, bundleDir });
+        const { checksumCrc32 } = packDirToTarGz(bundleDir);
+        built.push({ key: block.key, checksumCrc32, bundleDir });
+    }
+    return { blocks: built };
+}
+/** Print the build output as the sentinel-wrapped single-line JSON contract. */
+export function printBuildOutput(output) {
+    process.stdout.write(`${BUILD_OUTPUT_SENTINEL}${JSON.stringify(output)}${BUILD_OUTPUT_SENTINEL_CLOSE}\n`);
+}
+async function readCustomBlocks(entryPath) {
+    const mod = await import(pathToFileURL(entryPath).href);
+    const worker = resolveWorker(mod);
+    const manifest = readProp(worker, "manifest");
+    const capabilities = readProp(manifest, "capabilities");
+    if (!Array.isArray(capabilities)) {
+        throw new Error(`worker manifest at ${entryPath} has no capabilities array`);
+    }
+    const blocks = [];
+    for (const capability of capabilities) {
+        const block = asCustomBlock(capability);
+        if (block) {
+            blocks.push(block);
+        }
+    }
+    return blocks;
+}
+function resolveWorker(mod) {
+    const top = readProp(mod, "default");
+    if (top === undefined) {
+        throw new Error("worker module has no default export");
+    }
+    const nested = readProp(top, "default");
+    return nested ?? top;
+}
+function readProp(value, key) {
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    return value[key];
+}
+function asCustomBlock(value) {
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    const record = value;
+    if (record._tag !== "custom_block") {
+        return undefined;
+    }
+    if (typeof record.key !== "string") {
+        throw new Error("custom_block capability is missing a string key");
+    }
+    const config = record.config;
+    if (typeof config !== "object" || config === null) {
+        throw new Error(`custom_block "${record.key}" is missing config`);
+    }
+    const source = parseSource(record.key, config.source);
+    const dataSources = config.dataSources;
+    const manifest = config.manifest;
+    return {
+        key: record.key,
+        config: {
+            source,
+            ...(isStringRecord(dataSources) ? { dataSources } : {}),
+            manifest,
+        },
+    };
+}
+function parseSource(key, value) {
+    if (typeof value !== "object" || value === null) {
+        throw new Error(`custom_block "${key}" is missing a source`);
+    }
+    const source = value;
+    if (source.type === "project") {
+        if (typeof source.path !== "string") {
+            throw new Error(`custom_block "${key}" project source is missing a string path`);
+        }
+        return {
+            type: "project",
+            path: source.path,
+            ...(typeof source.command === "string"
+                ? { command: source.command }
+                : {}),
+            ...(typeof source.output === "string" ? { output: source.output } : {}),
+        };
+    }
+    if (source.type === "static") {
+        if (typeof source.path !== "string") {
+            throw new Error(`custom_block "${key}" static source is missing a string path`);
+        }
+        return { type: "static", path: source.path };
+    }
+    throw new Error(`custom_block "${key}" has an unsupported source type "${String(source.type)}" — this worker may need a newer @notionhq/workers`);
+}
+function isStringRecord(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    return Object.values(value).every(v => typeof v === "string");
+}
+function buildCustomBlock(args) {
+    const { block, projectRoot, bundleDir } = args;
+    const sourceDir = resolveSourceDir(block.key, block.config.source, projectRoot);
+    fs.rmSync(bundleDir, { recursive: true, force: true });
+    fs.mkdirSync(bundleDir, { recursive: true });
+    fs.cpSync(sourceDir, bundleDir, { recursive: true });
+}
+const DEFAULT_BUILD_COMMAND = "npm run build";
+const DEFAULT_OUTPUT_DIR = "dist";
+function resolveSourceDir(key, source, projectRoot) {
+    if (source.type === "static") {
+        const dir = path.resolve(projectRoot, source.path);
+        if (!fs.existsSync(dir)) {
+            throw new Error(`custom_block "${key}" static dir not found: ${dir}`);
+        }
+        return dir;
+    }
+    const projectDir = path.resolve(projectRoot, source.path);
+    if (!fs.existsSync(projectDir)) {
+        throw new Error(`custom_block "${key}" project dir not found: ${projectDir}`);
+    }
+    installProjectDeps(key, projectDir);
+    const command = source.command ?? DEFAULT_BUILD_COMMAND;
+    runCommand(key, command, projectDir);
+    const outputDir = path.resolve(projectDir, source.output ?? DEFAULT_OUTPUT_DIR);
+    if (!fs.existsSync(outputDir)) {
+        throw new Error(`custom_block "${key}" build command "${command}" produced no output at ${outputDir}`);
+    }
+    return outputDir;
+}
+/**
+ * Install a `project` source's own dependencies before building it. `npm ci`
+ * when a lockfile is present (faster + deterministic), else `npm install`. No-op
+ * when the project has no package.json.
+ */
+function installProjectDeps(key, projectDir) {
+    if (!fs.existsSync(path.join(projectDir, "package.json"))) {
+        return;
+    }
+    const hasLockfile = fs.existsSync(path.join(projectDir, "package-lock.json"));
+    runCommand(key, hasLockfile ? "npm ci" : "npm install", projectDir);
+}
+/**
+ * Run a shell command in `cwd`. The child's stdout/stderr are forwarded to our
+ * stderr so build/install logs never contaminate the sentinel-wrapped JSON
+ * contract this tool writes to stdout.
+ */
+function runCommand(key, command, cwd) {
+    const result = spawnSync(command, { cwd, shell: true, encoding: "utf8" });
+    if (result.stdout) {
+        process.stderr.write(result.stdout);
+    }
+    if (result.stderr) {
+        process.stderr.write(result.stderr);
+    }
+    if (result.error) {
+        throw new Error(`custom_block "${key}" build command "${command}" failed to start: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        throw new Error(`custom_block "${key}" build command "${command}" exited with code ${String(result.status)}`);
+    }
+}

package/bin/notion-custom-blocks/cli.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import { buildCustomBlocks, printBuildOutput } from "./build.js";
+import { parseUploadsInput, uploadViews } from "./upload.js";
+export async function main(argv) {
+    const [command, ...rest] = argv;
+    switch (command) {
+        case "build":
+            return runBuild(rest);
+        case "upload":
+            return runUpload(rest);
+        default:
+            printUsage();
+            return command === undefined ? 0 : 1;
+    }
+}
+async function runBuild(args) {
+    const flags = parseFlags(args);
+    const out = flags.out;
+    if (out === undefined) {
+        process.stderr.write("usage: notion-custom-blocks build --out <dir>\n");
+        return 1;
+    }
+    const output = await buildCustomBlocks({ out });
+    printBuildOutput(output);
+    return 0;
+}
+async function runUpload(args) {
+    const flags = parseFlags(args);
+    const raw = flags.uploads;
+    if (raw === undefined) {
+        process.stderr.write("usage: notion-custom-blocks upload --uploads '<json>'\n");
+        return 1;
+    }
+    const uploads = parseUploadsInput(raw);
+    const output = await uploadViews(uploads);
+    process.stdout.write(`${JSON.stringify(output)}\n`);
+    return 0;
+}
+function parseFlags(args) {
+    const flags = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === undefined || !arg.startsWith("--")) {
+            continue;
+        }
+        const name = arg.slice(2);
+        const value = args[i + 1];
+        if (value === undefined) {
+            continue;
+        }
+        flags[name] = value;
+        i++;
+    }
+    return flags;
+}
+function printUsage() {
+    process.stderr.write("Invalid command. See notion-custom-blocks source.");
+}
+main(process.argv.slice(2))
+    .then(code => {
+    process.exitCode = code;
+})
+    .catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});

package/bin/notion-custom-blocks/tar.js

@@ -0,0 +1,102 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as zlib from "node:zlib";
+/**
+ * Deterministic gzipped-tarball packing for custom-block bundles, shared by the
+ * `build` and `upload` phases.
+ */
+const BLOCK_SIZE = 512;
+/**
+ * Pack a directory into a deterministic gzipped tarball and return both the
+ * bytes and their base64 big-endian crc32 checksum (the form
+ * `CreateCustomBlockDeploy` signs into the presigned PUT URL).
+ */
+export function packDirToTarGz(dir) {
+    const entries = collectFiles(dir);
+    const tar = writeUstarArchive(entries);
+    const tarGz = zlib.gzipSync(tar, {
+        level: zlib.constants.Z_BEST_COMPRESSION,
+    });
+    // Zero the gzip header's MTIME field (bytes 4..7) so repeated packs of the
+    // same input are byte-identical. The build phase's crc32 must match the
+    // bytes the upload phase PUTs, and gzip otherwise stamps the current time.
+    if (tarGz.length >= 8) {
+        tarGz.writeUInt32LE(0, 4);
+    }
+    return { tarGz, checksumCrc32: crc32Base64(tarGz) };
+}
+/** Base64-encoded big-endian crc32, matching the server's `CRC32_BASE64_REGEX`. */
+export function crc32Base64(data) {
+    const checksum = zlib.crc32(data) >>> 0;
+    const buf = Buffer.alloc(4);
+    buf.writeUInt32BE(checksum);
+    return buf.toString("base64");
+}
+/** Recursively collect regular files under `dir`, sorted by archive path. */
+function collectFiles(dir) {
+    const entries = [];
+    function walk(absDir, relDir) {
+        const dirents = fs.readdirSync(absDir, { withFileTypes: true });
+        for (const dirent of dirents) {
+            const abs = path.join(absDir, dirent.name);
+            const rel = relDir === "" ? dirent.name : `${relDir}/${dirent.name}`;
+            if (dirent.isDirectory()) {
+                walk(abs, rel);
+            }
+            else if (dirent.isFile()) {
+                entries.push({ name: rel, contents: fs.readFileSync(abs) });
+            }
+        }
+    }
+    walk(dir, "");
+    entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    return entries;
+}
+/** Serialize entries as a minimal POSIX ustar archive. */
+function writeUstarArchive(entries) {
+    const chunks = [];
+    for (const entry of entries) {
+        chunks.push(writeUstarHeader(entry.name, entry.contents.length));
+        chunks.push(entry.contents);
+        const remainder = entry.contents.length % BLOCK_SIZE;
+        if (remainder !== 0) {
+            chunks.push(Buffer.alloc(BLOCK_SIZE - remainder));
+        }
+    }
+    // Two zero blocks mark end-of-archive.
+    chunks.push(Buffer.alloc(BLOCK_SIZE * 2));
+    return Buffer.concat(chunks);
+}
+function writeUstarHeader(name, size) {
+    const header = Buffer.alloc(BLOCK_SIZE);
+    const nameBytes = Buffer.from(name, "utf8");
+    if (nameBytes.length > 100) {
+        // ustar splits long paths into name/prefix; keep bundles simple by
+        // requiring short paths rather than emitting a GNU/PAX extension.
+        throw new Error(`tar entry path too long (max 100 bytes): ${name}`);
+    }
+    nameBytes.copy(header, 0);
+    writeOctal(header, 100, 8, 0o644); // mode
+    writeOctal(header, 108, 8, 0); // uid
+    writeOctal(header, 116, 8, 0); // gid
+    writeOctal(header, 124, 12, size); // size
+    writeOctal(header, 136, 12, 0); // mtime
+    header.write("0", 156, 1, "ascii"); // typeflag: regular file
+    header.write("ustar\0", 257, 6, "ascii"); // magic
+    header.write("00", 263, 2, "ascii"); // version
+    // Checksum field: spaces during computation, then octal value.
+    header.fill(" ", 148, 156);
+    let checksum = 0;
+    for (let i = 0; i < BLOCK_SIZE; i++) {
+        checksum += header[i] ?? 0;
+    }
+    header.write(checksum.toString(8).padStart(6, "0"), 148, 6, "ascii");
+    header.write("\0 ", 154, 2, "ascii");
+    return header;
+}
+function writeOctal(header, offset, length, value) {
+    // Numeric fields are octal ASCII, null-terminated, right-justified.
+    const str = value.toString(8).padStart(length - 1, "0");
+    header.write(str, offset, length - 1, "ascii");
+    header.write("\0", offset + length - 1, 1, "ascii");
+}

package/bin/notion-custom-blocks/upload.js

@@ -0,0 +1,60 @@
+import { packDirToTarGz } from "./tar.js";
+const DEFAULT_DEPS = { fetch: globalThis.fetch };
+export async function uploadViews(uploads, deps = DEFAULT_DEPS) {
+    const uploaded = {};
+    for (const [key, target] of Object.entries(uploads)) {
+        const { tarGz, checksumCrc32 } = packDirToTarGz(target.bundleDir);
+        const response = await deps.fetch(target.uploadUrl, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/gzip",
+                "x-amz-checksum-crc32": checksumCrc32,
+            },
+            body: new Uint8Array(tarGz),
+        });
+        if (!response.ok) {
+            const text = await safeReadText(response);
+            throw new Error(`upload failed for block "${key}": ${response.status} ${response.statusText}${text ? `\n${text}` : ""}`);
+        }
+        uploaded[key] = true;
+    }
+    return { uploaded };
+}
+export function parseUploadsInput(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`--uploads is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error("--uploads must be a JSON object of { key: target }");
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(parsed)) {
+        if (typeof value !== "object" || value === null) {
+            throw new Error(`--uploads["${key}"] must be an object`);
+        }
+        const record = value;
+        if (typeof record.uploadUrl !== "string") {
+            throw new Error(`--uploads["${key}"].uploadUrl must be a string`);
+        }
+        if (typeof record.bundleDir !== "string") {
+            throw new Error(`--uploads["${key}"].bundleDir must be a string`);
+        }
+        result[key] = {
+            uploadUrl: record.uploadUrl,
+            bundleDir: record.bundleDir,
+        };
+    }
+    return result;
+}
+async function safeReadText(response) {
+    try {
+        return await response.text();
+    }
+    catch {
+        return "";
+    }
+}

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

@@ -25,6 +25,22 @@ export declare const hostToSandboxMessageSchema: v.VariantSchema<"type", [v.Vari
     }, undefined>], undefined>;
     readonly page: v.ObjectSchema<{
         readonly id: v.CustomSchema<import("../ids.js").NotionPageId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        readonly parent: v.VariantSchema<"type", [v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"page_id", undefined>;
+            readonly page_id: v.CustomSchema<import("../ids.js").NotionPageId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"data_source_id", undefined>;
+            readonly data_source_id: v.CustomSchema<import("../ids.js").NotionDataSourceId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"workspace", undefined>;
+            readonly workspace: v.LiteralSchema<true, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"block_id", undefined>;
+            readonly block_id: v.CustomSchema<import("../ids.js").NotionBlockId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"agent_id", undefined>;
+            readonly agent_id: v.CustomSchema<import("../ids.js").NotionAgentId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>], undefined>;
     }, undefined>;
     readonly dataSources: v.ObjectSchema<{
         readonly bindings: v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
@@ -216,6 +232,22 @@ export declare const hostToSandboxMessageSchema: v.VariantSchema<"type", [v.Vari
     readonly type: v.LiteralSchema<"pageChanged", undefined>;
     readonly page: v.ObjectSchema<{
         readonly id: v.CustomSchema<import("../ids.js").NotionPageId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        readonly parent: v.VariantSchema<"type", [v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"page_id", undefined>;
+            readonly page_id: v.CustomSchema<import("../ids.js").NotionPageId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"data_source_id", undefined>;
+            readonly data_source_id: v.CustomSchema<import("../ids.js").NotionDataSourceId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"workspace", undefined>;
+            readonly workspace: v.LiteralSchema<true, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"block_id", undefined>;
+            readonly block_id: v.CustomSchema<import("../ids.js").NotionBlockId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"agent_id", undefined>;
+            readonly agent_id: v.CustomSchema<import("../ids.js").NotionAgentId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>], undefined>;
     }, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly type: v.LiteralSchema<"currentUserChanged", undefined>;

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

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

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

@@ -41,6 +41,22 @@ export declare const initMessageSchema: v.VariantSchema<"status", [v.ObjectSchem
     }, undefined>], undefined>;
     readonly page: v.ObjectSchema<{
         readonly id: v.CustomSchema<import("../ids.js").NotionPageId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        readonly parent: v.VariantSchema<"type", [v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"page_id", undefined>;
+            readonly page_id: v.CustomSchema<import("../ids.js").NotionPageId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"data_source_id", undefined>;
+            readonly data_source_id: v.CustomSchema<import("../ids.js").NotionDataSourceId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"workspace", undefined>;
+            readonly workspace: v.LiteralSchema<true, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"block_id", undefined>;
+            readonly block_id: v.CustomSchema<import("../ids.js").NotionBlockId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"agent_id", undefined>;
+            readonly agent_id: v.CustomSchema<import("../ids.js").NotionAgentId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>], undefined>;
     }, undefined>;
     readonly dataSources: v.ObjectSchema<{
         readonly bindings: v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{

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

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/bridge/messages/init.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AASxD,eAAO,MAAM,8BAA8B,2BAAa,CAAA;AAExD,MAAM,MAAM,wBAAwB,GACjC,UAAU,GACV,eAAe,GACf,sBAAsB,GACtB,kBAAkB,GAClB,0BAA0B,GAC1B,8BAA8B,GAC9B,qBAAqB,GACrB,0BAA0B,GAC1B,6BAA6B,GAC7B,yBAAyB,GACzB,0BAA0B,GAC1B,0BAA0B,GAC1B,eAAe,GACf,cAAc,GACd,eAAe,GACf,CAAC,MAAM,GAAG,EAAE,CAAC,CAAA;AAEhB,MAAM,MAAM,wBAAwB,GACnC,oBAAoB,CAAC,wBAAwB,CAAC,CAAA;AAE/C,eAAO,MAAM,8BAA8B;;;;aAIzC,CAAA;AAEF,qBAAa,oBACZ,SAAQ,KACR,YAAW,oBAAoB;gBAEnB,KAAK,EAAE,wBAAwB;IAO3C,IAAI,EAAE,wBAAwB,CAAA;IAC9B,WAAW,EAAE,OAAO,CAAA;CACpB;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAkB5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAA"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/bridge/messages/init.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AASxD,eAAO,MAAM,8BAA8B,2BAAa,CAAA;AAExD,MAAM,MAAM,wBAAwB,GACjC,UAAU,GACV,eAAe,GACf,sBAAsB,GACtB,kBAAkB,GAClB,0BAA0B,GAC1B,8BAA8B,GAC9B,qBAAqB,GACrB,0BAA0B,GAC1B,6BAA6B,GAC7B,yBAAyB,GACzB,0BAA0B,GAC1B,0BAA0B,GAC1B,eAAe,GACf,cAAc,GACd,eAAe,GACf,CAAC,MAAM,GAAG,EAAE,CAAC,CAAA;AAEhB,MAAM,MAAM,wBAAwB,GACnC,oBAAoB,CAAC,wBAAwB,CAAC,CAAA;AAE/C,eAAO,MAAM,8BAA8B;;;;aAIzC,CAAA;AAEF,qBAAa,oBACZ,SAAQ,KACR,YAAW,oBAAoB;gBAEnB,KAAK,EAAE,wBAAwB;IAO3C,IAAI,EAAE,wBAAwB,CAAA;IAC9B,WAAW,EAAE,OAAO,CAAA;CACpB;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAkB5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

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

@@ -6,6 +6,22 @@ export declare const pageChangedMessageSchema: v.ObjectSchema<{
     readonly type: v.LiteralSchema<"pageChanged", undefined>;
     readonly page: v.ObjectSchema<{
         readonly id: v.CustomSchema<import("../ids.js").NotionPageId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        readonly parent: v.VariantSchema<"type", [v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"page_id", undefined>;
+            readonly page_id: v.CustomSchema<import("../ids.js").NotionPageId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"data_source_id", undefined>;
+            readonly data_source_id: v.CustomSchema<import("../ids.js").NotionDataSourceId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"workspace", undefined>;
+            readonly workspace: v.LiteralSchema<true, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"block_id", undefined>;
+            readonly block_id: v.CustomSchema<import("../ids.js").NotionBlockId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"agent_id", undefined>;
+            readonly agent_id: v.CustomSchema<import("../ids.js").NotionAgentId, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>], undefined>;
     }, undefined>;
 }, undefined>;
 export type PageChangedMessage = v.InferOutput<typeof pageChangedMessageSchema>;

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

@@ -1 +1 @@
-{"version":3,"file":"pageChanged.d.ts","sourceRoot":"","sources":["../../../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/bridge/messages/pageChanged.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAG5B;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;aAGnC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAA"}
+{"version":3,"file":"pageChanged.d.ts","sourceRoot":"","sources":["../../../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/bridge/messages/pageChanged.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAG5B;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;aAGnC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAA"}

package/dist/bridge/pages/page.d.ts

@@ -6,8 +6,32 @@
  */
 import * as v from "valibot";
 export type { NotionPageId } from "../ids.js";
+/**
+ * The custom block's nearest enclosing page ancestor, carried in `init.page` and `pageChanged`.
+ */
 export declare const customBlockPageSchema: v.ObjectSchema<{
     readonly id: v.CustomSchema<import("./page.js").NotionPageId, v.ErrorMessage<v.CustomIssue> | undefined>;
+    /**
+     * The containing page's own parent. It lets a block distinguish a freestanding page from a
+     * database row without a round trip. Not to be confused with the top-level `parent` runtime
+     * value, which is the custom block's own parent.
+     */
+    readonly parent: v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"page_id", undefined>;
+        readonly page_id: v.CustomSchema<import("./page.js").NotionPageId, v.ErrorMessage<v.CustomIssue> | undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"data_source_id", undefined>;
+        readonly data_source_id: v.CustomSchema<import("../ids.js").NotionDataSourceId, v.ErrorMessage<v.CustomIssue> | undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"workspace", undefined>;
+        readonly workspace: v.LiteralSchema<true, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"block_id", undefined>;
+        readonly block_id: v.CustomSchema<import("../ids.js").NotionBlockId, v.ErrorMessage<v.CustomIssue> | undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"agent_id", undefined>;
+        readonly agent_id: v.CustomSchema<import("../ids.js").NotionAgentId, v.ErrorMessage<v.CustomIssue> | undefined>;
+    }, undefined>], undefined>;
 }, undefined>;
 export type CustomBlockPage = v.InferOutput<typeof customBlockPageSchema>;
 /**

package/dist/bridge/pages/page.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../../../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/bridge/pages/page.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../../../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/bridge/pages/page.ts"],"names":[],"mappings":"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"}

package/dist/bridge/pages/page.js

@@ -7,8 +7,17 @@
 import * as v from "valibot";
 import { notionDataSourceIdSchema, notionPageIdSchema } from "../ids.js";
 import { notionParentSchema } from "../parent.js";
+/**
+ * The custom block's nearest enclosing page ancestor, carried in `init.page` and `pageChanged`.
+ */
 export const customBlockPageSchema = v.object({
     id: notionPageIdSchema,
+    /**
+     * The containing page's own parent. It lets a block distinguish a freestanding page from a
+     * database row without a round trip. Not to be confused with the top-level `parent` runtime
+     * value, which is the custom block's own parent.
+     */
+    parent: notionParentSchema,
 });
 /**
  * Parent reference accepted by `pages.create` / `pages.update` inputs.

package/dist/index.d.ts

@@ -32,6 +32,6 @@ export type { NotionParent } from "./bridge/parent.js";
 export { pages, users } from "./bridge/sandboxClient.js";
 export type { NotionTheme } from "./bridge/theme.js";
 export { type CustomBlockState, customBlock } from "./customBlock.js";
-export { type CustomBlockInitial, type InitCustomBlockOptions, initCustomBlock, NotInIframeError, } from "./init.js";
+export { type CustomBlockInitPayload, type InitCustomBlockOptions, initCustomBlock, NotInIframeError, } from "./init.js";
 export * from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,YAAY,EACX,sBAAsB,EACtB,gBAAgB,GAChB,MAAM,oCAAoC,CAAA;AAC3C,YAAY,EACX,oBAAoB,EACpB,+BAA+B,EAC/B,gCAAgC,GAChC,MAAM,wCAAwC,CAAA;AAC/C,YAAY,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAA;AACpF,YAAY,EACX,UAAU,EACV,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,mBAAmB,EACnB,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,GAClB,MAAM,mCAAmC,CAAA;AAC1C,YAAY,EACX,wCAAwC,EACxC,wCAAwC,GACxC,MAAM,gCAAgC,CAAA;AACvC,YAAY,EACX,uBAAuB,EACvB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,GACjB,MAAM,wCAAwC,CAAA;AAC/C,OAAO,EACN,2BAA2B,EAC3B,qBAAqB,GACrB,MAAM,wCAAwC,CAAA;AAC/C,YAAY,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAA;AAChF,YAAY,EACX,4BAA4B,EAC5B,4BAA4B,GAC5B,MAAM,yCAAyC,CAAA;AAChD,YAAY,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAC9D,YAAY,EACX,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,aAAa,GACb,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACX,mBAAmB,EACnB,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,GAChB,MAAM,sBAAsB,CAAA;AAC7B,YAAY,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAA;AAC/E,YAAY,EACX,8BAA8B,EAC9B,8BAA8B,GAC9B,MAAM,uCAAuC,CAAA;AAC9C,YAAY,EACX,2BAA2B,EAC3B,2BAA2B,GAC3B,MAAM,8BAA8B,CAAA;AACrC,YAAY,EACX,2BAA2B,EAC3B,2BAA2B,GAC3B,MAAM,8BAA8B,CAAA;AACrC,YAAY,EACX,wBAAwB,EACxB,wBAAwB,GACxB,MAAM,2BAA2B,CAAA;AAClC,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAChE,YAAY,EACX,6BAA6B,EAC7B,6BAA6B,GAC7B,MAAM,gCAAgC,CAAA;AACvC,YAAY,EACX,mCAAmC,EACnC,mCAAmC,GACnC,MAAM,4CAA4C,CAAA;AACnD,YAAY,EACX,8BAA8B,EAC9B,8BAA8B,GAC9B,MAAM,uCAAuC,CAAA;AAC9C,YAAY,EACX,UAAU,EACV,eAAe,EACf,cAAc,EACd,YAAY,EACZ,0BAA0B,EAC1B,4BAA4B,EAC5B,uBAAuB,EACvB,0BAA0B,GAC1B,MAAM,wBAAwB,CAAA;AAC/B,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAA;AACxD,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,KAAK,gBAAgB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACrE,OAAO,EACN,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,eAAe,EACf,gBAAgB,GAChB,MAAM,WAAW,CAAA;AAClB,cAAc,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,YAAY,EACX,sBAAsB,EACtB,gBAAgB,GAChB,MAAM,oCAAoC,CAAA;AAC3C,YAAY,EACX,oBAAoB,EACpB,+BAA+B,EAC/B,gCAAgC,GAChC,MAAM,wCAAwC,CAAA;AAC/C,YAAY,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAA;AACpF,YAAY,EACX,UAAU,EACV,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,mBAAmB,EACnB,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,GAClB,MAAM,mCAAmC,CAAA;AAC1C,YAAY,EACX,wCAAwC,EACxC,wCAAwC,GACxC,MAAM,gCAAgC,CAAA;AACvC,YAAY,EACX,uBAAuB,EACvB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,GACjB,MAAM,wCAAwC,CAAA;AAC/C,OAAO,EACN,2BAA2B,EAC3B,qBAAqB,GACrB,MAAM,wCAAwC,CAAA;AAC/C,YAAY,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAA;AAChF,YAAY,EACX,4BAA4B,EAC5B,4BAA4B,GAC5B,MAAM,yCAAyC,CAAA;AAChD,YAAY,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAC9D,YAAY,EACX,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,aAAa,GACb,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACX,mBAAmB,EACnB,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,GAChB,MAAM,sBAAsB,CAAA;AAC7B,YAAY,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAA;AAC/E,YAAY,EACX,8BAA8B,EAC9B,8BAA8B,GAC9B,MAAM,uCAAuC,CAAA;AAC9C,YAAY,EACX,2BAA2B,EAC3B,2BAA2B,GAC3B,MAAM,8BAA8B,CAAA;AACrC,YAAY,EACX,2BAA2B,EAC3B,2BAA2B,GAC3B,MAAM,8BAA8B,CAAA;AACrC,YAAY,EACX,wBAAwB,EACxB,wBAAwB,GACxB,MAAM,2BAA2B,CAAA;AAClC,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAChE,YAAY,EACX,6BAA6B,EAC7B,6BAA6B,GAC7B,MAAM,gCAAgC,CAAA;AACvC,YAAY,EACX,mCAAmC,EACnC,mCAAmC,GACnC,MAAM,4CAA4C,CAAA;AACnD,YAAY,EACX,8BAA8B,EAC9B,8BAA8B,GAC9B,MAAM,uCAAuC,CAAA;AAC9C,YAAY,EACX,UAAU,EACV,eAAe,EACf,cAAc,EACd,YAAY,EACZ,0BAA0B,EAC1B,4BAA4B,EAC5B,uBAAuB,EACvB,0BAA0B,GAC1B,MAAM,wBAAwB,CAAA;AAC/B,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAA;AACxD,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,KAAK,gBAAgB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACrE,OAAO,EACN,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,eAAe,EACf,gBAAgB,GAChB,MAAM,WAAW,CAAA;AAClB,cAAc,YAAY,CAAA"}

package/dist/init.d.ts

@@ -8,7 +8,7 @@ import type { NotionUser } from "./bridge/users/user.js";
 /**
  * The payload sent by the host in the `init` message in response to the sandbox's `ready` message.
  */
-export type CustomBlockInitial = {
+export type CustomBlockInitPayload = {
     theme: NotionTheme;
     blockId: NotionBlockId;
     parent: NotionParent;
@@ -49,5 +49,5 @@ export type InitCustomBlockOptions = {
  * Mount your React tree (or call any SDK hook / `customBlock.subscribe`) only after the
  * returned promise resolves.
  */
-export declare function initCustomBlock(opts?: InitCustomBlockOptions): Promise<CustomBlockInitial>;
+export declare function initCustomBlock(opts?: InitCustomBlockOptions): Promise<CustomBlockInitPayload>;
 //# sourceMappingURL=init.d.ts.map

package/dist/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/init.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAA;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEpD,OAAO,EAEN,KAAK,wBAAwB,EAE7B,MAAM,2BAA2B,CAAA;AAClC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAExD;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAChC,KAAK,EAAE,WAAW,CAAA;IAClB,OAAO,EAAE,aAAa,CAAA;IACtB,MAAM,EAAE,YAAY,CAAA;IACpB,IAAI,EAAE,eAAe,CAAA;IACrB,WAAW,EAAE,UAAU,CAAA;IACvB,WAAW,EAAE,gBAAgB,EAAE,CAAA;CAC/B,CAAA;AAED;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;gBAC9B,OAAO,GAAE,MAA8B;IAOnD,IAAI,EAAE,wBAAwB,CAAA;IAC9B,WAAW,EAAE,OAAO,CAAA;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACpC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AASD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC9B,IAAI,GAAE,sBAA2B,GAC/B,OAAO,CAAC,kBAAkB,CAAC,CAyD7B"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/init.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAA;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEpD,OAAO,EAEN,KAAK,wBAAwB,EAE7B,MAAM,2BAA2B,CAAA;AAClC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAExD;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACpC,KAAK,EAAE,WAAW,CAAA;IAClB,OAAO,EAAE,aAAa,CAAA;IACtB,MAAM,EAAE,YAAY,CAAA;IACpB,IAAI,EAAE,eAAe,CAAA;IACrB,WAAW,EAAE,UAAU,CAAA;IACvB,WAAW,EAAE,gBAAgB,EAAE,CAAA;CAC/B,CAAA;AAED;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;gBAC9B,OAAO,GAAE,MAA8B;IAOnD,IAAI,EAAE,wBAAwB,CAAA;IAC9B,WAAW,EAAE,OAAO,CAAA;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACpC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AASD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC9B,IAAI,GAAE,sBAA2B,GAC/B,OAAO,CAAC,sBAAsB,CAAC,CAyDjC"}

package/dist/react/standalonePreview.js

@@ -10,7 +10,7 @@ export function seedStandalonePreviewState() {
         theme: "light",
         blockId: previewBlockId,
         parent: { type: "page_id", page_id: previewPageId },
-        page: { id: previewPageId },
+        page: { id: previewPageId, parent: { type: "workspace", workspace: true } },
         dataSources: { bindings: {} },
         currentUser: {
             object: "user",

package/dist/react/useCustomBlockInit.d.ts

@@ -1,5 +1,5 @@
 import { CustomBlockInitError } from "../bridge/messages/init.js";
-import { type CustomBlockInitial, type InitCustomBlockOptions, NotInIframeError } from "../init.js";
+import { type CustomBlockInitPayload, type InitCustomBlockOptions, NotInIframeError } from "../init.js";
 export type CustomBlockInitFailure = CustomBlockInitError | NotInIframeError;
 /**
  * Discriminated state returned by {@link useCustomBlockInit}.
@@ -20,7 +20,7 @@ export type UseCustomBlockInitResult = {
 } | {
     isLoaded: true;
     error: undefined;
-    initial: CustomBlockInitial;
+    initial: CustomBlockInitPayload;
 };
 /**
  * React wrapper around {@link initCustomBlock}. Kicks off the SDK ↔ host

package/dist/react/useCustomBlockInit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCustomBlockInit.d.ts","sourceRoot":"","sources":["../../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/react/useCustomBlockInit.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AACjE,OAAO,EACN,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAE3B,gBAAgB,EAChB,MAAM,YAAY,CAAA;AAEnB,MAAM,MAAM,sBAAsB,GAAG,oBAAoB,GAAG,gBAAgB,CAAA;AAE5E;;;;;;;;;GASG;AACH,MAAM,MAAM,wBAAwB,GACjC;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GACrC;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,sBAAsB,CAAA;CAAE,GAClD;IAAE,QAAQ,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,kBAAkB,CAAA;CAAE,CAAA;AAEpE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,CAAC,EAAE,sBAAsB,GAC3B,wBAAwB,CA8B1B"}
+{"version":3,"file":"useCustomBlockInit.d.ts","sourceRoot":"","sources":["../../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/react/useCustomBlockInit.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AACjE,OAAO,EACN,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAE3B,gBAAgB,EAChB,MAAM,YAAY,CAAA;AAEnB,MAAM,MAAM,sBAAsB,GAAG,oBAAoB,GAAG,gBAAgB,CAAA;AAE5E;;;;;;;;;GASG;AACH,MAAM,MAAM,wBAAwB,GACjC;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GACrC;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,sBAAsB,CAAA;CAAE,GAClD;IAAE,QAAQ,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,sBAAsB,CAAA;CAAE,CAAA;AAExE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,CAAC,EAAE,sBAAsB,GAC3B,wBAAwB,CA8B1B"}

package/dist/version.js

@@ -4,4 +4,4 @@
  *
  * WARNING: Generated during SDK publish. Do not edit in the published package.
  */
-export const NCBLOCK_SDK_VERSION = "0.0.61"
+export const NCBLOCK_SDK_VERSION = "0.0.63"

package/docs/block-location.md

@@ -63,12 +63,26 @@ export function AgentInstructionBadge() {
 
 Returns the nearest enclosing `page` / `collection_view_page` ancestor.
 
-Re-renders when the host sends a block location update.
+Re-renders when the host sends a block location update — including when the containing page itself moves (its `parent` changes) without the page ID changing.
 
 ```ts
-function usePage(): { id: NotionPageId };
+function usePage(): CustomBlockPage;
+
+type CustomBlockPage = {
+  id: NotionPageId;
+  parent: NotionParent; // the containing page's own parent
+};
 ```
 
+`page.parent` allows determining if the custom block is in a freestanding page or part of a database. Don't confuse it with `useParent()`, which is the custom block's own parent.
+
+```tsx
+const page = usePage();
+const isInsideDatabaseRow = page.parent.type === "data_source_id";
+```
+
+For anything beyond location — title, icon, properties — fetch the page through the pages API: `pages.get(page.id)`.
+
 For non-React renderers, use `customBlock.getPage()` after `initCustomBlock()` resolves.
 
 ### `useTheme()`

package/docs/lifecycle.md

@@ -4,7 +4,7 @@ The SDK ↔ host handshake, the React wrapper that runs it, and the auto-resize
 
 ## Handshake
 
-`initCustomBlock()` posts `ready` to `window.parent` and awaits the host's `init` (theme, block ID/parent/page ID, current user, and `dataSources: { bindings }` keyed by semantic data-source key, which the SDK resolves against the manifest). The promise resolves with the normalized initial state, captured in `CustomBlockInitial` — `await` it before mounting React so hooks always see populated state.
+`initCustomBlock()` posts `ready` to `window.parent` and awaits the host's `init` (theme, block ID/parent/page ID, current user, and `dataSources: { bindings }` keyed by semantic data-source key, which the SDK resolves against the manifest). The promise resolves with the normalized initial state, captured in `CustomBlockInitPayload` — `await` it before mounting React so hooks always see populated state.
 
 - Default `timeoutMs` is 15000; rejects with `CustomBlockInitError` code `init_timeout` if the host doesn't respond.
 - In a top-level browser tab (no parent frame), rejects with `NotInIframeError` code `not_in_iframe`. `<NotionCustomBlock>` catches this, seeds placeholders, and renders `children` behind a warning banner so dev-time previews still work.
@@ -45,7 +45,7 @@ function useCustomBlockInit(
 type UseCustomBlockInitResult =
   | { isLoaded: false; error: undefined }
   | { isLoaded: false; error: CustomBlockInitFailure }
-  | { isLoaded: true; error: undefined; initial: CustomBlockInitial };
+  | { isLoaded: true; error: undefined; initial: CustomBlockInitPayload };
 ```
 
 React wrapper around `initCustomBlock` for templates that prefer not to use top-level `await`. Multiple components calling it share the same handshake.
@@ -64,7 +64,7 @@ function Root() {
 ```ts
 function initCustomBlock(
   opts?: InitCustomBlockOptions,
-): Promise<CustomBlockInitial>;
+): Promise<CustomBlockInitPayload>;
 
 type InitCustomBlockOptions = { timeoutMs?: number };
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@notionhq/custom-blocks",
-	"version": "0.0.61",
+	"version": "0.0.63",
 	"license": "MIT",
 	"type": "module",
 	"publishConfig": {
@@ -32,7 +32,8 @@
 		}
 	},
 	"bin": {
-		"ncblock": "./bin/cli/cli.js"
+		"ncblock": "./bin/cli/cli.js",
+		"notion-custom-blocks": "./bin/notion-custom-blocks/cli.js"
 	},
 	"scripts": {
 		"test": "vitest run --environment jsdom",

package/src/bridge/pages/page.ts

@@ -11,8 +11,17 @@ import { notionParentSchema } from "../parent.js"
 
 export type { NotionPageId } from "../ids.js"
 
+/**
+ * The custom block's nearest enclosing page ancestor, carried in `init.page` and `pageChanged`.
+ */
 export const customBlockPageSchema = v.object({
 	id: notionPageIdSchema,
+	/**
+	 * The containing page's own parent. It lets a block distinguish a freestanding page from a
+	 * database row without a round trip. Not to be confused with the top-level `parent` runtime
+	 * value, which is the custom block's own parent.
+	 */
+	parent: notionParentSchema,
 })
 
 export type CustomBlockPage = v.InferOutput<typeof customBlockPageSchema>

package/src/index.ts

@@ -108,7 +108,7 @@ export { pages, users } from "./bridge/sandboxClient.js"
 export type { NotionTheme } from "./bridge/theme.js"
 export { type CustomBlockState, customBlock } from "./customBlock.js"
 export {
-	type CustomBlockInitial,
+	type CustomBlockInitPayload,
 	type InitCustomBlockOptions,
 	initCustomBlock,
 	NotInIframeError,

package/src/init.ts

@@ -15,7 +15,7 @@ import type { NotionUser } from "./bridge/users/user.js"
 /**
  * The payload sent by the host in the `init` message in response to the sandbox's `ready` message.
  */
-export type CustomBlockInitial = {
+export type CustomBlockInitPayload = {
 	theme: NotionTheme
 	blockId: NotionBlockId
 	parent: NotionParent
@@ -60,7 +60,7 @@ const DEFAULT_INIT_TIMEOUT_MS = 15_000
 const NOT_IN_IFRAME_MESSAGE =
 	"<NotionCustomBlock> only works inside an iframe — use the dev shell or deploy to Notion."
 
-let initPromise: Promise<CustomBlockInitial> | undefined
+let initPromise: Promise<CustomBlockInitPayload> | undefined
 
 /**
  * Performs the SDK <-> host handshake: loads `custom_blocks.json`, posts
@@ -74,7 +74,7 @@ let initPromise: Promise<CustomBlockInitial> | undefined
  */
 export function initCustomBlock(
 	opts: InitCustomBlockOptions = {},
-): Promise<CustomBlockInitial> {
+): Promise<CustomBlockInitPayload> {
 	if (initPromise === undefined) {
 		initPromise = (async () => {
 			// Fail fast with a typed error when rendered as a standalone tab and not in a parent frame.

package/src/react/standalonePreview.ts

@@ -12,7 +12,7 @@ export function seedStandalonePreviewState() {
 		theme: "light",
 		blockId: previewBlockId,
 		parent: { type: "page_id", page_id: previewPageId },
-		page: { id: previewPageId },
+		page: { id: previewPageId, parent: { type: "workspace", workspace: true } },
 		dataSources: { bindings: {} },
 		currentUser: {
 			object: "user",

package/src/react/useCustomBlockInit.ts

@@ -1,7 +1,7 @@
 import { useEffect, useState } from "react"
 import { CustomBlockInitError } from "../bridge/messages/init.js"
 import {
-	type CustomBlockInitial,
+	type CustomBlockInitPayload,
 	type InitCustomBlockOptions,
 	initCustomBlock,
 	NotInIframeError,
@@ -22,7 +22,7 @@ export type CustomBlockInitFailure = CustomBlockInitError | NotInIframeError
 export type UseCustomBlockInitResult =
 	| { isLoaded: false; error: undefined }
 	| { isLoaded: false; error: CustomBlockInitFailure }
-	| { isLoaded: true; error: undefined; initial: CustomBlockInitial }
+	| { isLoaded: true; error: undefined; initial: CustomBlockInitPayload }
 
 /**
  * React wrapper around {@link initCustomBlock}. Kicks off the SDK ↔ host