@wp-typia/project-tools 0.14.0 → 0.15.1

package/dist/runtime/schema-core.js

@@ -149,15 +149,35 @@ function applyProjectedTypeTag(schema, typeTag, path) {
             throw new Error(`Unsupported wp-typia schema type tag "${typeTag}" at "${path}".`);
     }
 }
+function canProjectTypeTag(typeTag) {
+    switch (typeTag) {
+        case "uint32":
+        case "int32":
+        case "float":
+        case "double":
+            return true;
+        default:
+            return false;
+    }
+}
 function projectSchemaArrayItemsForAiStructuredOutput(items, path) {
     return items.map((item, index) => projectSchemaObjectForAiStructuredOutput(item, `${path}/${index}`));
 }
+function projectSchemaArrayItemsForRest(items, path) {
+    return items.map((item, index) => projectSchemaObjectForRest(item, `${path}/${index}`));
+}
 function projectSchemaPropertyMapForAiStructuredOutput(properties, path) {
     return Object.fromEntries(Object.entries(properties).map(([key, value]) => [
         key,
         projectSchemaObjectForAiStructuredOutput(value, `${path}/${key}`),
     ]));
 }
+function projectSchemaPropertyMapForRest(properties, path) {
+    return Object.fromEntries(Object.entries(properties).map(([key, value]) => [
+        key,
+        projectSchemaObjectForRest(value, `${path}/${key}`),
+    ]));
+}
 function projectSchemaObjectForAiStructuredOutput(node, path) {
     const projectedNode = cloneJsonSchemaNode(node);
     const rawTypeTag = projectedNode[WP_TYPIA_OPENAPI_EXTENSION_KEYS.TYPE_TAG];
@@ -188,6 +208,126 @@ function projectSchemaObjectForAiStructuredOutput(node, path) {
     }
     return projectedNode;
 }
+function projectSchemaObjectForRest(node, path) {
+    const projectedNode = cloneJsonSchemaNode(node);
+    const rawTypeTag = projectedNode[WP_TYPIA_OPENAPI_EXTENSION_KEYS.TYPE_TAG];
+    if (typeof rawTypeTag === "string" && canProjectTypeTag(rawTypeTag)) {
+        applyProjectedTypeTag(projectedNode, rawTypeTag, path);
+    }
+    for (const key of Object.keys(projectedNode)) {
+        const child = projectedNode[key];
+        if (Array.isArray(child)) {
+            projectedNode[key] = child.every(isJsonSchemaObject)
+                ? projectSchemaArrayItemsForRest(child, `${path}/${key}`)
+                : child;
+            continue;
+        }
+        if (!isJsonSchemaObject(child)) {
+            continue;
+        }
+        if (key === "properties") {
+            projectedNode[key] = projectSchemaPropertyMapForRest(child, `${path}/${key}`);
+            continue;
+        }
+        projectedNode[key] = projectSchemaObjectForRest(child, `${path}/${key}`);
+    }
+    applyProjectedBootstrapContract(projectedNode);
+    return projectedNode;
+}
+function applyProjectedBootstrapContract(schema) {
+    if (schema.type !== "object" || !isJsonSchemaObject(schema.properties)) {
+        return;
+    }
+    const properties = schema.properties;
+    const buildRequiredPropertyObject = (requiredKeys) => Object.fromEntries(requiredKeys.map((requiredKey) => [requiredKey, properties[requiredKey] ?? {}]));
+    if (properties.canWrite?.type !== "boolean") {
+        return;
+    }
+    const allOf = Array.isArray(schema.allOf)
+        ? [...schema.allOf]
+        : [];
+    const canWriteIsTrue = {
+        properties: {
+            canWrite: {
+                const: true,
+            },
+        },
+        required: ["canWrite"],
+    };
+    const hasRestNonce = properties.restNonce?.type === "string";
+    const hasPublicWriteCredential = properties.publicWriteToken?.type === "string" &&
+        isJsonSchemaObject(properties.publicWriteExpiresAt);
+    if (hasRestNonce && hasPublicWriteCredential) {
+        allOf.push({
+            if: canWriteIsTrue,
+            then: {
+                anyOf: [
+                    {
+                        properties: buildRequiredPropertyObject(["restNonce"]),
+                        required: ["restNonce"],
+                    },
+                    {
+                        properties: buildRequiredPropertyObject([
+                            "publicWriteExpiresAt",
+                            "publicWriteToken",
+                        ]),
+                        required: ["publicWriteExpiresAt", "publicWriteToken"],
+                    },
+                ],
+            },
+            else: {
+                not: {
+                    anyOf: [
+                        {
+                            properties: buildRequiredPropertyObject(["restNonce"]),
+                            required: ["restNonce"],
+                        },
+                        {
+                            properties: buildRequiredPropertyObject(["publicWriteToken"]),
+                            required: ["publicWriteToken"],
+                        },
+                    ],
+                },
+            },
+        });
+    }
+    if (hasRestNonce && !hasPublicWriteCredential) {
+        allOf.push({
+            if: canWriteIsTrue,
+            then: {
+                properties: buildRequiredPropertyObject(["restNonce"]),
+                required: ["restNonce"],
+            },
+            else: {
+                not: {
+                    properties: buildRequiredPropertyObject(["restNonce"]),
+                    required: ["restNonce"],
+                },
+            },
+        });
+    }
+    if (hasPublicWriteCredential && !hasRestNonce) {
+        allOf.push({
+            if: canWriteIsTrue,
+            then: {
+                properties: buildRequiredPropertyObject([
+                    "publicWriteExpiresAt",
+                    "publicWriteToken",
+                ]),
+                required: ["publicWriteExpiresAt", "publicWriteToken"],
+            },
+            else: {
+                not: {
+                    properties: buildRequiredPropertyObject(["publicWriteToken"]),
+                    required: ["publicWriteToken"],
+                },
+            },
+        });
+    }
+    if (allOf.length > 0) {
+        schema.allOf = allOf;
+    }
+}
 function manifestUnionToJsonSchema(union) {
     const oneOf = Object.entries(union.branches).map(([branchKey, branch]) => {
         if (branch.ts.kind !== "object") {
@@ -305,7 +445,7 @@ export function manifestToJsonSchema(doc) {
  */
 export function projectJsonSchemaDocument(schema, options) {
     if (options.profile === "rest") {
-        return cloneJsonSchemaNode(schema);
+        return projectSchemaObjectForRest(schema, "#");
     }
     if (options.profile === "ai-structured-output") {
         return projectSchemaObjectForAiStructuredOutput(schema, "#");
@@ -321,10 +461,14 @@ export function projectJsonSchemaDocument(schema, options) {
  */
 export function manifestToOpenApi(doc, info = {}) {
     const schemaName = doc.sourceType ?? "TypiaDocument";
+    const projectedSchema = projectJsonSchemaDocument(manifestToJsonSchema(doc), {
+        profile: "rest",
+    });
+    delete projectedSchema.$schema;
     return {
         components: {
             schemas: {
-                [schemaName]: manifestToJsonSchema(doc),
+                [schemaName]: projectedSchema,
             },
         },
         info: {
@@ -486,7 +630,36 @@ function buildQueryParameters(contract) {
         schema: manifestAttributeToJsonSchema(attribute),
     }));
 }
-function createSuccessResponse(schemaName) {
+function createBootstrapResponseHeaders(normalizedAuth) {
+    const headers = {
+        "Cache-Control": {
+            description: "Must be non-cacheable for fresh bootstrap write/session state.",
+            schema: {
+                type: "string",
+                example: "private, no-store, no-cache, must-revalidate",
+            },
+        },
+        Pragma: {
+            description: "Legacy non-cacheable bootstrap response directive.",
+            schema: {
+                type: "string",
+                example: "no-cache",
+            },
+        },
+    };
+    if (normalizedAuth.wordpressAuth?.mechanism ===
+        WP_TYPIA_OPENAPI_LITERALS.WORDPRESS_REST_NONCE_MECHANISM) {
+        headers.Vary = {
+            description: "Viewer-aware bootstrap responses should vary on cookie-backed auth state.",
+            schema: {
+                type: "string",
+                example: "Cookie",
+            },
+        };
+    }
+    return headers;
+}
+function createSuccessResponse(schemaName, headers) {
     return {
         content: {
             [WP_TYPIA_OPENAPI_LITERALS.JSON_CONTENT_TYPE]: {
@@ -494,14 +667,18 @@ function createSuccessResponse(schemaName) {
             },
         },
         description: WP_TYPIA_OPENAPI_LITERALS.SUCCESS_RESPONSE_DESCRIPTION,
+        ...(headers ? { headers } : {}),
     };
 }
 function buildEndpointOpenApiOperation(endpoint, contracts) {
     const normalizedAuth = normalizeEndpointAuthDefinition(endpoint);
+    const isBootstrapEndpoint = endpoint.path.endsWith("/bootstrap");
     const operation = {
         operationId: endpoint.operationId,
         responses: {
-            "200": createSuccessResponse(getContractSchemaName(endpoint.responseContract, contracts[endpoint.responseContract], endpoint, "response")),
+            "200": createSuccessResponse(getContractSchemaName(endpoint.responseContract, contracts[endpoint.responseContract], endpoint, "response"), isBootstrapEndpoint
+                ? createBootstrapResponseHeaders(normalizedAuth)
+                : undefined),
         },
         tags: [...endpoint.tags],
         [WP_TYPIA_OPENAPI_EXTENSION_KEYS.AUTH_INTENT]: normalizedAuth.auth,
@@ -554,10 +731,13 @@ function buildEndpointOpenApiOperation(endpoint, contracts) {
  */
 export function buildEndpointOpenApiDocument(options) {
     const contractEntries = Object.entries(options.contracts);
-    const schemas = Object.fromEntries(contractEntries.map(([contractKey, contract]) => [
-        getContractSchemaName(contractKey, contract),
-        manifestToJsonSchema(contract.document),
-    ]));
+    const schemas = Object.fromEntries(contractEntries.map(([contractKey, contract]) => {
+        const projectedSchema = projectJsonSchemaDocument(manifestToJsonSchema(contract.document), {
+            profile: "rest",
+        });
+        delete projectedSchema.$schema;
+        return [getContractSchemaName(contractKey, contract), projectedSchema];
+    }));
     const paths = {};
     const topLevelTags = [...new Set(options.endpoints.flatMap((endpoint) => endpoint.tags))]
         .filter((tag) => typeof tag === "string" && tag.length > 0)

package/dist/runtime/template-builtins.js

@@ -59,7 +59,7 @@ export async function resolveBuiltInTemplateSource(templateId, options = {}) {
         throw error;
     }
     return {
-        id: template.id,
+        id: templateId,
         defaultCategory: template.defaultCategory,
         description: template.description,
         features: template.features,

package/dist/runtime/template-registry.d.ts

@@ -15,10 +15,11 @@ export declare const SHARED_WORKSPACE_TEMPLATE_ROOT: string;
 export declare const SHARED_TEST_PRESET_TEMPLATE_ROOT: string;
 export declare const SHARED_WP_ENV_PRESET_TEMPLATE_ROOT: string;
 export declare const BUILTIN_TEMPLATE_IDS: readonly ["basic", "interactivity", "persistence", "compound"];
+export declare const OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE = "@wp-typia/create-workspace-template";
 export type BuiltInTemplateId = (typeof BUILTIN_TEMPLATE_IDS)[number];
 export type PersistencePolicy = "authenticated" | "public";
 export interface TemplateDefinition {
-    id: BuiltInTemplateId;
+    id: string;
     description: string;
     defaultCategory: string;
     features: string[];

package/dist/runtime/template-registry.js

@@ -41,6 +41,7 @@ export const SHARED_WORKSPACE_TEMPLATE_ROOT = path.join(SHARED_TEMPLATE_ROOT, "w
 export const SHARED_TEST_PRESET_TEMPLATE_ROOT = path.join(SHARED_PRESET_TEMPLATE_ROOT, "test-preset");
 export const SHARED_WP_ENV_PRESET_TEMPLATE_ROOT = path.join(SHARED_PRESET_TEMPLATE_ROOT, "wp-env");
 export const BUILTIN_TEMPLATE_IDS = ["basic", "interactivity", "persistence", "compound"];
+export const OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE = "@wp-typia/create-workspace-template";
 export const TEMPLATE_REGISTRY = Object.freeze([
     {
         id: "basic",
@@ -70,8 +71,15 @@ export const TEMPLATE_REGISTRY = Object.freeze([
         features: ["InnerBlocks", "Hidden child blocks", "Optional persistence layer"],
         templateDir: path.join(TEMPLATE_ROOT, "compound"),
     },
+    {
+        id: OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE,
+        description: "The official empty workspace template that powers `wp-typia add ...` workflows",
+        defaultCategory: "workspace",
+        features: ["Workspace inventory", "Add block workflows", "Workspace doctor and migrate"],
+        templateDir: path.resolve(PROJECT_TOOLS_PACKAGE_ROOT, "..", "create-workspace-template"),
+    },
 ]);
-export const TEMPLATE_IDS = TEMPLATE_REGISTRY.map((template) => template.id);
+export const TEMPLATE_IDS = [...BUILTIN_TEMPLATE_IDS];
 export function isBuiltInTemplateId(templateId) {
     return BUILTIN_TEMPLATE_IDS.includes(templateId);
 }
@@ -81,7 +89,10 @@ export function listTemplates() {
 export function getTemplateById(templateId) {
     const template = TEMPLATE_REGISTRY.find((entry) => entry.id === templateId);
     if (!template) {
-        throw new Error(`Unknown template "${templateId}". Expected one of: ${TEMPLATE_IDS.join(", ")}`);
+        throw new Error(`Unknown template "${templateId}". Expected one of: ${[
+            ...TEMPLATE_IDS,
+            OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE,
+        ].join(", ")}`);
     }
     return template;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/project-tools",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "description": "Project orchestration and programmatic tooling for wp-typia",
   "packageManager": "bun@1.3.11",
   "type": "module",
@@ -69,6 +69,7 @@
     "npm-package-arg": "^13.0.0",
     "semver": "^7.7.3",
     "tar": "^7.4.3",
+    "typia": "^12.0.1",
     "typescript": "^5.9.2"
   },
   "devDependencies": {

package/templates/_shared/compound/core/scripts/add-compound-child.ts.mustache

@@ -2,14 +2,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-const PARENT_BLOCK_NAME = '{{namespace}}/{{slugKebabCase}}';
-const PARENT_BLOCK_NAMESPACE = '{{namespace}}';
-const PARENT_BLOCK_SLUG = '{{slugKebabCase}}';
-const PARENT_BLOCK_TITLE = {{titleJson}};
-const PARENT_TYPE_NAME = '{{pascalCase}}';
-const PARENT_STYLE_IMPORT = '../{{slugKebabCase}}/style.scss';
 const PROJECT_ROOT = process.cwd();
-const TEXT_DOMAIN = '{{textDomain}}';
 
 const ALLOWED_CHILD_MARKER = '// add-child: insert new allowed child block names here';
 const BLOCK_CONFIG_MARKER = '// add-child: insert new block config entries here';
@@ -22,6 +15,16 @@ type StarterManifestDocument = {
 	sourceType: string;
 };
 
+type CompoundParentConfig = {
+	blockName: string;
+	namespace: string;
+	slug: string;
+	styleImport: string;
+	textDomain: string;
+	title: string;
+	typeName: string;
+};
+
 function parseArgs() {
 	const args = process.argv.slice( 2 );
 	const parsed: {
@@ -81,6 +84,26 @@ function toTitleCase( input: string ): string {
 		.join( ' ' );
 }
 
+function readJsonFile( filePath: string ): Record< string, unknown > {
+	let parsed: unknown;
+
+	try {
+		parsed = JSON.parse( fs.readFileSync( filePath, 'utf8' ) );
+	} catch ( error ) {
+		const errorMessage = error instanceof Error ? error.message : String( error );
+		throw new Error(
+			`Unable to parse JSON from ${ filePath }: ${ errorMessage }`,
+			{ cause: error instanceof Error ? error : undefined }
+		);
+	}
+
+	if ( ! parsed || typeof parsed !== 'object' || Array.isArray( parsed ) ) {
+		throw new Error( `${ filePath } must contain a JSON object.` );
+	}
+
+	return parsed as Record< string, unknown >;
+}
+
 function resolveValidatedNamespace( value: string ): string {
 	const normalizedNamespace = toKebabCase( value );
 
@@ -101,6 +124,79 @@ function resolveValidatedBlockSlug( value: string ): string {
 	return normalizedSlug;
 }
 
+function resolveCompoundParentConfig(): CompoundParentConfig {
+	const blocksRoot = path.join( PROJECT_ROOT, 'src', 'blocks' );
+
+	if ( ! fs.existsSync( blocksRoot ) ) {
+		throw new Error(
+			'This command expects a compound scaffold with src/blocks/<parent>/children.ts and scripts/block-config.ts.'
+		);
+	}
+
+	const parentCandidates = fs
+		.readdirSync( blocksRoot, { withFileTypes: true } )
+		.filter( ( entry ) => entry.isDirectory() )
+		.map( ( entry ) => path.join( blocksRoot, entry.name ) )
+		.filter( ( candidateDir ) =>
+			fs.existsSync( path.join( candidateDir, 'children.ts' ) )
+		);
+
+	if ( parentCandidates.length !== 1 ) {
+		throw new Error(
+			`Unable to resolve the compound parent block. Expected exactly one src/blocks/<parent>/children.ts entry, found ${ parentCandidates.length }.`
+		);
+	}
+
+	const parentDir = parentCandidates[ 0 ];
+	const parentSlug = resolveValidatedBlockSlug( path.basename( parentDir ) );
+	const blockJsonPath = path.join( parentDir, 'block.json' );
+
+	if ( ! fs.existsSync( blockJsonPath ) ) {
+		throw new Error( `Unable to resolve ${ blockJsonPath } for the compound parent block.` );
+	}
+
+	const blockJson = readJsonFile( blockJsonPath );
+	const blockName = typeof blockJson.name === 'string' ? blockJson.name.trim() : '';
+	const separatorIndex = blockName.indexOf( '/' );
+
+	if ( separatorIndex <= 0 || separatorIndex === blockName.length - 1 ) {
+		throw new Error(
+			`The parent block metadata at ${ blockJsonPath } must declare a valid "name" like "namespace/slug".`
+		);
+	}
+
+	const namespace = resolveValidatedNamespace( blockName.slice( 0, separatorIndex ) );
+	const title =
+		typeof blockJson.title === 'string' && blockJson.title.trim().length > 0
+			? blockJson.title.trim()
+			: toTitleCase( parentSlug );
+	const textDomain =
+		typeof blockJson.textdomain === 'string' &&
+		blockJson.textdomain.trim().length > 0
+			? blockJson.textdomain.trim()
+			: parentSlug;
+
+	return {
+		blockName,
+		namespace,
+		slug: parentSlug,
+		styleImport: `../${ parentSlug }/style.scss`,
+		textDomain,
+		title,
+		typeName: toPascalCase( parentSlug ),
+	};
+}
+
+const {
+	blockName: PARENT_BLOCK_NAME,
+	namespace: PARENT_BLOCK_NAMESPACE,
+	slug: PARENT_BLOCK_SLUG,
+	styleImport: PARENT_STYLE_IMPORT,
+	textDomain: TEXT_DOMAIN,
+	title: PARENT_BLOCK_TITLE,
+	typeName: PARENT_TYPE_NAME,
+} = resolveCompoundParentConfig();
+
 function buildBlockCssClassName( namespace: string, slug: string ): string {
 	const normalizedSlug = resolveValidatedBlockSlug( slug );
 	const normalizedNamespace =

package/templates/_shared/compound/persistence/scripts/block-config.ts.mustache

@@ -9,9 +9,15 @@ export const BLOCKS = [
 				'state-query': {
 					sourceTypeName: '{{pascalCase}}StateQuery',
 				},
+				'bootstrap-query': {
+					sourceTypeName: '{{pascalCase}}BootstrapQuery',
+				},
 				'write-state-request': {
 					sourceTypeName: '{{pascalCase}}WriteStateRequest',
 				},
+				'bootstrap-response': {
+					sourceTypeName: '{{pascalCase}}BootstrapResponse',
+				},
 				'state-response': {
 					sourceTypeName: '{{pascalCase}}StateResponse',
 				},
@@ -40,6 +46,16 @@ export const BLOCKS = [
 						mechanism: '{{restWriteAuthMechanism}}',
 					},
 				},
+				{
+					auth: 'public',
+					method: 'GET',
+					operationId: 'get{{pascalCase}}Bootstrap',
+					path: '/{{namespace}}/v1/{{slugKebabCase}}/bootstrap',
+					queryContract: 'bootstrap-query',
+					responseContract: 'bootstrap-response',
+					summary: 'Read fresh session bootstrap state for the current viewer.',
+					tags: [ '{{title}}' ],
+				},
 			],
 			info: {
 				title: '{{title}} REST API',

package/templates/_shared/compound/persistence/src/blocks/{{slugKebabCase}}/api-types.ts.mustache

@@ -5,6 +5,11 @@ export interface {{pascalCase}}StateQuery {
 	resourceKey: string & tags.MinLength< 1 > & tags.MaxLength< 100 >;
 }
 
+export interface {{pascalCase}}BootstrapQuery {
+	postId: number & tags.Type< 'uint32' >;
+	resourceKey: string & tags.MinLength< 1 > & tags.MaxLength< 100 >;
+}
+
 export interface {{pascalCase}}WriteStateRequest {
 	postId: number & tags.Type< 'uint32' >;
 	{{publicWriteRequestIdDeclaration}}
@@ -13,6 +18,11 @@ export interface {{pascalCase}}WriteStateRequest {
 	delta?: number & tags.Minimum< 1 > & tags.Type< 'uint32' > & tags.Default< 1 >;
 }
 
+export interface {{pascalCase}}BootstrapResponse {
+	canWrite: boolean;
+	{{bootstrapCredentialDeclarations}}
+}
+
 export interface {{pascalCase}}StateResponse {
 	postId: number & tags.Type< 'uint32' >;
 	resourceKey: string & tags.MinLength< 1 > & tags.MaxLength< 100 >;

package/templates/_shared/compound/persistence/src/blocks/{{slugKebabCase}}/api.ts.mustache

@@ -3,10 +3,12 @@ import {
 } from '@wp-typia/rest';
 
 import {
+	type {{pascalCase}}BootstrapQuery,
 	type {{pascalCase}}StateQuery,
 	type {{pascalCase}}WriteStateRequest,
 } from './api-types';
 import {
+	get{{pascalCase}}BootstrapEndpoint,
 	get{{pascalCase}}StateEndpoint,
 	write{{pascalCase}}StateEndpoint,
 } from './api-client';
@@ -15,6 +17,10 @@ import {
 	type PersistenceTransportOptions,
 } from './transport';
 
+export const bootstrapEndpoint = {
+	...get{{pascalCase}}BootstrapEndpoint,
+};
+
 export const stateEndpoint = {
 	...get{{pascalCase}}StateEndpoint,
 };
@@ -40,6 +46,23 @@ export function fetchState(
 	);
 }
 
+export function fetchBootstrap(
+	request: {{pascalCase}}BootstrapQuery,
+	options: PersistenceTransportOptions = {}
+) {
+	return callEndpoint(
+		bootstrapEndpoint,
+		request,
+		resolveTransportCallOptions(
+			options.transportTarget ?? 'frontend',
+			'read',
+			bootstrapEndpoint,
+			request,
+			options
+		)
+	);
+}
+
 export function writeState(
 	request: {{pascalCase}}WriteStateRequest,
 	options: PersistenceTransportOptions = {}

package/templates/_shared/compound/persistence/src/blocks/{{slugKebabCase}}/data.ts.mustache

@@ -6,11 +6,14 @@ import {
 } from '@wp-typia/rest/react';
 
 import type {
+	{{pascalCase}}BootstrapQuery,
+	{{pascalCase}}BootstrapResponse,
 	{{pascalCase}}StateQuery,
 	{{pascalCase}}StateResponse,
 	{{pascalCase}}WriteStateRequest,
 } from './api-types';
 import {
+	bootstrapEndpoint,
 	stateEndpoint,
 	writeStateEndpoint,
 } from './api';
@@ -40,6 +43,20 @@ export interface Use{{pascalCase}}StateQueryOptions<
 	transportTarget?: PersistenceTransportTarget;
 }
 
+export interface Use{{pascalCase}}BootstrapQueryOptions<
+	Selected = {{pascalCase}}BootstrapResponse,
+> extends Omit<
+	UseEndpointQueryOptions<
+		{{pascalCase}}BootstrapQuery,
+		{{pascalCase}}BootstrapResponse,
+		Selected
+	>,
+	'resolveCallOptions'
+> {
+	restNonce?: string;
+	transportTarget?: PersistenceTransportTarget;
+}
+
 export interface UseWrite{{pascalCase}}StateMutationOptions<
 	Context = unknown,
 > extends Omit<
@@ -92,6 +109,34 @@ export function use{{pascalCase}}StateQuery<
 	} );
 }
 
+export function use{{pascalCase}}BootstrapQuery<
+	Selected = {{pascalCase}}BootstrapResponse,
+>(
+	request: {{pascalCase}}BootstrapQuery,
+	options: Use{{pascalCase}}BootstrapQueryOptions< Selected > = {}
+) {
+	const {
+		restNonce,
+		transportTarget = 'editor',
+		...queryOptions
+	} = options;
+
+	return useEndpointQuery( bootstrapEndpoint, request, {
+		...queryOptions,
+		resolveCallOptions: () =>
+			resolveTransportCallOptions(
+				transportTarget,
+				'read',
+				bootstrapEndpoint,
+				request,
+				{
+					restNonce,
+					transportTarget,
+				}
+			),
+	} );
+}
+
 export function useWrite{{pascalCase}}StateMutation<
 	Context = unknown,
 >(