@wp-typia/project-tools 0.20.2 → 0.22.0

package/dist/runtime/template-source-seeds.js

@@ -6,6 +6,8 @@ import { spawnSync } from 'node:child_process';
 import semver from 'semver';
 import { x as extractTarball } from 'tar';
 import { createExternalTemplateTimeoutError, fetchWithExternalTemplateTimeout, getExternalTemplateMetadataMaxBytes, getExternalTemplateTarballMaxBytes, getExternalTemplateTimeoutMs, readBufferResponseWithLimit, readJsonResponseWithLimit, } from './external-template-guards.js';
+import { findReusableExternalTemplateSourceCache, isExternalTemplateCacheEnabled, resolveExternalTemplateSourceCache, } from './template-source-cache.js';
+import { CLI_DIAGNOSTIC_CODES, createCliDiagnosticCodeError, } from './cli-diagnostics.js';
 import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, OFFICIAL_WORKSPACE_TEMPLATE_ALIAS, PROJECT_TOOLS_PACKAGE_ROOT, TEMPLATE_IDS, } from './template-registry.js';
 import { isPlainObject } from './object-utils.js';
 import { createManagedTempRoot } from './temp-roots.js';
@@ -13,6 +15,19 @@ const USER_FACING_TEMPLATE_IDS = [
     ...TEMPLATE_IDS,
     OFFICIAL_WORKSPACE_TEMPLATE_ALIAS,
 ];
+const GITHUB_TEMPLATE_CACHE_REVISION_RACE_CODE = 'github-template-cache-revision-race';
+function createGitHubTemplateCacheRevisionRaceError(message) {
+    const error = new Error(message);
+    error.code = GITHUB_TEMPLATE_CACHE_REVISION_RACE_CODE;
+    return error;
+}
+function isGitHubTemplateCacheRevisionRaceError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code ===
+            GITHUB_TEMPLATE_CACHE_REVISION_RACE_CODE);
+}
 function getUnknownNpmTemplateMessage(templateId) {
     return [
         `Unknown template "${templateId}". Expected one of: ${USER_FACING_TEMPLATE_IDS.join(', ')}.`,
@@ -20,6 +35,44 @@ function getUnknownNpmTemplateMessage(templateId) {
         'If you meant an npm template package, verify the package name and configured npm registry.',
     ].join(' ');
 }
+function readOptionalDistString(dist, key) {
+    const value = dist[key];
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function normalizeNpmRegistryCacheKey(registryBase) {
+    try {
+        const url = new URL(registryBase);
+        url.username = '';
+        url.password = '';
+        url.search = '';
+        url.hash = '';
+        return url.toString().replace(/\/$/u, '');
+    }
+    catch {
+        return registryBase;
+    }
+}
+async function downloadNpmTemplateTarball(locator, resolvedVersion, tarballUrl, unpackDir) {
+    const tarballResponse = await fetchWithExternalTemplateTimeout(tarballUrl, {
+        label: `downloading npm template tarball for ${locator.raw}@${resolvedVersion}`,
+    });
+    if (!tarballResponse.ok) {
+        throw new Error(`Failed to download npm template tarball for ${locator.raw}: ${tarballResponse.status}`);
+    }
+    const tarballPath = path.join(path.dirname(unpackDir), 'template.tgz');
+    await fsp.mkdir(unpackDir, { recursive: true });
+    await fsp.writeFile(tarballPath, await readBufferResponseWithLimit(tarballResponse, {
+        label: `npm template tarball for ${locator.raw}@${resolvedVersion}`,
+        maxBytes: getExternalTemplateTarballMaxBytes(),
+    }));
+    await extractTarball({
+        cwd: unpackDir,
+        file: tarballPath,
+        strip: 1,
+    });
+    await fsp.rm(tarballPath, { force: true });
+    await assertNoSymlinks(unpackDir);
+}
 function selectRegistryVersion(metadata, locator) {
     const distTags = isPlainObject(metadata['dist-tags'])
         ? metadata['dist-tags']
@@ -61,7 +114,7 @@ async function fetchNpmTemplateSource(locator) {
     });
     if (!metadataResponse.ok) {
         if (metadataResponse.status === 404) {
-            throw new Error(getUnknownNpmTemplateMessage(locator.raw));
+            throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, getUnknownNpmTemplateMessage(locator.raw));
         }
         throw new Error(`Failed to fetch npm template metadata for ${locator.raw}: ${metadataResponse.status}`);
     }
@@ -79,27 +132,43 @@ async function fetchNpmTemplateSource(locator) {
     if (typeof tarballUrl !== 'string' || tarballUrl.length === 0) {
         throw new Error(`npm template metadata is missing tarball URL for ${locator.raw}@${resolvedVersion}.`);
     }
+    const tarballIntegrity = readOptionalDistString(versionMetadata.dist, 'integrity');
+    const tarballShasum = readOptionalDistString(versionMetadata.dist, 'shasum');
+    if (tarballIntegrity || tarballShasum) {
+        const registryCacheKey = normalizeNpmRegistryCacheKey(registryBase);
+        const cachedSource = await resolveExternalTemplateSourceCache({
+            keyParts: [
+                'npm',
+                registryCacheKey,
+                locator.name,
+                locator.raw,
+                resolvedVersion,
+                tarballIntegrity ?? '',
+                tarballShasum ?? '',
+            ],
+            metadata: {
+                integrity: tarballIntegrity,
+                package: locator.name,
+                raw: locator.raw,
+                registry: registryBase,
+                shasum: tarballShasum,
+                tarball: tarballUrl,
+                version: resolvedVersion,
+            },
+            namespace: 'npm',
+        }, (unpackDir) => downloadNpmTemplateTarball(locator, resolvedVersion, tarballUrl, unpackDir));
+        if (cachedSource) {
+            await assertNoSymlinks(cachedSource.sourceDir);
+            return {
+                blockDir: cachedSource.sourceDir,
+                rootDir: cachedSource.sourceDir,
+            };
+        }
+    }
     const { path: tempRoot, cleanup } = await createManagedTempRoot('wp-typia-template-source-');
     try {
-        const tarballResponse = await fetchWithExternalTemplateTimeout(tarballUrl, {
-            label: `downloading npm template tarball for ${locator.raw}@${resolvedVersion}`,
-        });
-        if (!tarballResponse.ok) {
-            throw new Error(`Failed to download npm template tarball for ${locator.raw}: ${tarballResponse.status}`);
-        }
-        const tarballPath = path.join(tempRoot, 'template.tgz');
         const unpackDir = path.join(tempRoot, 'source');
-        await fsp.mkdir(unpackDir, { recursive: true });
-        await fsp.writeFile(tarballPath, await readBufferResponseWithLimit(tarballResponse, {
-            label: `npm template tarball for ${locator.raw}@${resolvedVersion}`,
-            maxBytes: getExternalTemplateTarballMaxBytes(),
-        }));
-        await extractTarball({
-            cwd: unpackDir,
-            file: tarballPath,
-            strip: 1,
-        });
-        await assertNoSymlinks(unpackDir);
+        await downloadNpmTemplateTarball(locator, resolvedVersion, tarballUrl, unpackDir);
         return {
             blockDir: unpackDir,
             cleanup,
@@ -200,47 +269,244 @@ export async function assertNoSymlinks(sourceDir) {
         await assertNoSymlinks(path.join(sourceDir, entry));
     }
 }
-async function resolveGitHubTemplateSource(locator) {
-    const { path: remoteRoot, cleanup } = await createManagedTempRoot('wp-typia-template-source-');
-    const checkoutDir = path.join(remoteRoot, 'source');
-    try {
-        const args = ['clone', '--depth', '1'];
-        if (locator.ref) {
-            args.push('--branch', locator.ref);
-        }
-        args.push(`https://github.com/${locator.owner}/${locator.repo}.git`, checkoutDir);
-        const cloneTimeoutMs = getExternalTemplateTimeoutMs();
-        const cloneResult = spawnSync('git', args, {
+function runGitTemplateCommand(args, label, options = {}) {
+    const timeoutMs = getExternalTemplateTimeoutMs();
+    const result = options.captureOutput
+        ? spawnSync('git', args, {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: timeoutMs,
+        })
+        : spawnSync('git', args, {
             stdio: 'ignore',
-            timeout: cloneTimeoutMs,
+            timeout: timeoutMs,
         });
-        if (cloneResult.error) {
-            const errorCode = typeof cloneResult.error === 'object' &&
-                cloneResult.error !== null &&
-                'code' in cloneResult.error
-                ? String(cloneResult.error.code)
-                : '';
-            if (errorCode === 'ETIMEDOUT') {
-                throw createExternalTemplateTimeoutError(`cloning GitHub template ${locator.owner}/${locator.repo}`, cloneTimeoutMs);
-            }
-            throw cloneResult.error;
+    if (result.error) {
+        const errorCode = typeof result.error === 'object' &&
+            result.error !== null &&
+            'code' in result.error
+            ? String(result.error.code)
+            : '';
+        if (errorCode === 'ETIMEDOUT') {
+            throw createExternalTemplateTimeoutError(label, timeoutMs);
         }
-        if (cloneResult.signal === 'SIGTERM' ||
-            cloneResult.signal === 'SIGKILL') {
-            throw createExternalTemplateTimeoutError(`cloning GitHub template ${locator.owner}/${locator.repo}`, cloneTimeoutMs);
+        throw result.error;
+    }
+    if (result.signal === 'SIGTERM' || result.signal === 'SIGKILL') {
+        throw createExternalTemplateTimeoutError(label, timeoutMs);
+    }
+    return result;
+}
+function getGitHubTemplateRepositoryUrl(locator) {
+    return `https://github.com/${locator.owner}/${locator.repo}.git`;
+}
+function resolveGitHubTemplateDirectory(checkoutDir, locator) {
+    const sourceDir = path.resolve(checkoutDir, locator.sourcePath);
+    const relativeSourceDir = path.relative(checkoutDir, sourceDir);
+    if (relativeSourceDir.startsWith('..') || path.isAbsolute(relativeSourceDir)) {
+        throw new Error('GitHub template path must stay within the cloned repository.');
+    }
+    if (!fs.existsSync(sourceDir)) {
+        throw new Error(`GitHub template path does not exist: ${locator.sourcePath}`);
+    }
+    return sourceDir;
+}
+function cloneGitHubTemplateSource(locator, checkoutDir) {
+    const args = ['clone', '--depth', '1'];
+    if (locator.ref) {
+        args.push('--branch', locator.ref);
+    }
+    args.push(getGitHubTemplateRepositoryUrl(locator), checkoutDir);
+    const cloneResult = runGitTemplateCommand(args, `cloning GitHub template ${locator.owner}/${locator.repo}`);
+    if (cloneResult.status !== 0) {
+        throw new Error(`Failed to clone GitHub template source ${locator.owner}/${locator.repo}.`);
+    }
+}
+function readGitHubTemplateHeadRevision(checkoutDir) {
+    const result = runGitTemplateCommand(['-C', checkoutDir, 'rev-parse', 'HEAD'], 'reading GitHub template checkout revision', { captureOutput: true });
+    if (result.status !== 0 || typeof result.stdout !== 'string') {
+        return null;
+    }
+    const revision = result.stdout.trim().split(/\s+/u)[0];
+    return /^[0-9a-f]{40}$/iu.test(revision) ? revision.toLowerCase() : null;
+}
+function pinGitHubTemplateCacheRevision(locator, checkoutDir, cacheRevision) {
+    const normalizedCacheRevision = cacheRevision.toLowerCase();
+    if (readGitHubTemplateHeadRevision(checkoutDir) === normalizedCacheRevision) {
+        return;
+    }
+    const fetchResult = runGitTemplateCommand(['-C', checkoutDir, 'fetch', '--depth', '1', 'origin', cacheRevision], `fetching GitHub template revision ${locator.owner}/${locator.repo}`);
+    if (fetchResult.status !== 0) {
+        throw createGitHubTemplateCacheRevisionRaceError(`Failed to fetch GitHub template revision ${cacheRevision} for ${locator.owner}/${locator.repo}.`);
+    }
+    const checkoutResult = runGitTemplateCommand(['-C', checkoutDir, 'checkout', '--detach', cacheRevision], `checking out GitHub template revision ${locator.owner}/${locator.repo}`);
+    if (checkoutResult.status !== 0) {
+        throw createGitHubTemplateCacheRevisionRaceError(`Failed to check out GitHub template revision ${cacheRevision} for ${locator.owner}/${locator.repo}.`);
+    }
+    if (readGitHubTemplateHeadRevision(checkoutDir) !== normalizedCacheRevision) {
+        throw createGitHubTemplateCacheRevisionRaceError(`GitHub template checkout did not match resolved revision ${cacheRevision} for ${locator.owner}/${locator.repo}.`);
+    }
+}
+function getGitHubTemplateRevisionPatterns(locator) {
+    const ref = locator.ref ?? 'HEAD';
+    if (!locator.ref) {
+        return [ref];
+    }
+    if (ref.startsWith('refs/')) {
+        return [ref, `${ref}^{}`];
+    }
+    return [ref, `refs/heads/${ref}`, `refs/tags/${ref}`, `refs/tags/${ref}^{}`];
+}
+function pickGitHubTemplateCacheRevision(locator, revisions) {
+    const ref = locator.ref ?? 'HEAD';
+    if (!locator.ref) {
+        return revisions[0]?.revision ?? null;
+    }
+    if (!ref.startsWith('refs/')) {
+        const branchRevision = revisions.find((entry) => entry.resolvedRef === `refs/heads/${ref}`);
+        if (branchRevision) {
+            return branchRevision.revision;
         }
-        if (cloneResult.status !== 0) {
-            throw new Error(`Failed to clone GitHub template source ${locator.owner}/${locator.repo}.`);
+        const peeledTagRevision = revisions.find((entry) => entry.resolvedRef === `refs/tags/${ref}^{}`);
+        if (peeledTagRevision) {
+            return peeledTagRevision.revision;
         }
-        const sourceDir = path.resolve(checkoutDir, locator.sourcePath);
-        const relativeSourceDir = path.relative(checkoutDir, sourceDir);
-        if (relativeSourceDir.startsWith('..') ||
-            path.isAbsolute(relativeSourceDir)) {
-            throw new Error('GitHub template path must stay within the cloned repository.');
+        const tagRevision = revisions.find((entry) => entry.resolvedRef === `refs/tags/${ref}`);
+        if (tagRevision) {
+            return tagRevision.revision;
         }
-        if (!fs.existsSync(sourceDir)) {
-            throw new Error(`GitHub template path does not exist: ${locator.sourcePath}`);
+    }
+    if (ref.startsWith('refs/tags/')) {
+        const peeledRevision = revisions.find((entry) => entry.resolvedRef === `${ref}^{}`);
+        if (peeledRevision) {
+            return peeledRevision.revision;
+        }
+    }
+    const exactRevision = revisions.find((entry) => entry.resolvedRef === ref);
+    return (exactRevision ?? revisions[0])?.revision ?? null;
+}
+/**
+ * Resolves a GitHub template ref to a stable revision for cache keying.
+ *
+ * @param locator GitHub template locator containing owner, repo, and optional ref.
+ * @returns Revision lookup result, including whether `git ls-remote` was unavailable.
+ */
+function resolveGitHubTemplateCacheRevision(locator) {
+    const result = runGitTemplateCommand([
+        'ls-remote',
+        getGitHubTemplateRepositoryUrl(locator),
+        ...getGitHubTemplateRevisionPatterns(locator),
+    ], `checking GitHub template revision ${locator.owner}/${locator.repo}`, { captureOutput: true });
+    if (result.status !== 0 || typeof result.stdout !== 'string') {
+        return {
+            lookupUnavailable: true,
+            revision: null,
+        };
+    }
+    const revisions = result.stdout
+        .split('\n')
+        .map((line) => {
+        const [revision, resolvedRef] = line.trim().split(/\s+/u);
+        if (!/^[0-9a-f]{40}$/iu.test(revision) || !resolvedRef) {
+            return null;
+        }
+        return {
+            resolvedRef,
+            revision: revision.toLowerCase(),
+        };
+    })
+        .filter((entry) => entry !== null);
+    return {
+        lookupUnavailable: false,
+        revision: pickGitHubTemplateCacheRevision(locator, revisions),
+    };
+}
+function getGitHubTemplateCacheMetadata(locator, revision) {
+    return {
+        ...(revision ? { revision } : {}),
+        owner: locator.owner,
+        ref: locator.ref,
+        repo: locator.repo,
+        sourcePath: locator.sourcePath,
+    };
+}
+async function reuseGitHubTemplateCacheByMetadata(locator) {
+    const cachedSource = await findReusableExternalTemplateSourceCache({
+        metadata: getGitHubTemplateCacheMetadata(locator),
+        namespace: 'github',
+    });
+    if (!cachedSource) {
+        return null;
+    }
+    const sourceDir = resolveGitHubTemplateDirectory(cachedSource.sourceDir, locator);
+    await assertNoSymlinks(sourceDir);
+    return {
+        blockDir: sourceDir,
+        rootDir: sourceDir,
+    };
+}
+async function resolveGitHubTemplateSource(locator) {
+    const cacheEnabled = isExternalTemplateCacheEnabled();
+    let cacheRevisionLookupUnavailable = false;
+    let cacheRevision = null;
+    if (cacheEnabled) {
+        try {
+            const resolvedRevision = resolveGitHubTemplateCacheRevision(locator);
+            cacheRevision = resolvedRevision.revision;
+            cacheRevisionLookupUnavailable = resolvedRevision.lookupUnavailable;
+        }
+        catch {
+            cacheRevision = null;
+            cacheRevisionLookupUnavailable = true;
         }
+    }
+    if (cacheEnabled && !cacheRevision && cacheRevisionLookupUnavailable) {
+        const cachedSource = await reuseGitHubTemplateCacheByMetadata(locator);
+        if (cachedSource) {
+            return cachedSource;
+        }
+    }
+    if (cacheRevision) {
+        const resolvedCacheRevision = cacheRevision;
+        try {
+            const cachedSource = await resolveExternalTemplateSourceCache({
+                keyParts: [
+                    'github',
+                    locator.owner,
+                    locator.repo,
+                    locator.sourcePath,
+                    locator.ref ?? '',
+                    resolvedCacheRevision,
+                ],
+                metadata: getGitHubTemplateCacheMetadata(locator, resolvedCacheRevision),
+                namespace: 'github',
+            }, async (checkoutDir) => {
+                cloneGitHubTemplateSource(locator, checkoutDir);
+                const sourceDir = resolveGitHubTemplateDirectory(checkoutDir, locator);
+                await assertNoSymlinks(sourceDir);
+                pinGitHubTemplateCacheRevision(locator, checkoutDir, resolvedCacheRevision);
+            });
+            if (cachedSource) {
+                const sourceDir = resolveGitHubTemplateDirectory(cachedSource.sourceDir, locator);
+                await assertNoSymlinks(sourceDir);
+                return {
+                    blockDir: sourceDir,
+                    rootDir: sourceDir,
+                };
+            }
+        }
+        catch (error) {
+            if (!isGitHubTemplateCacheRevisionRaceError(error)) {
+                throw error;
+            }
+            // Fall back to the existing uncached clone path if revision pinning races.
+        }
+    }
+    const { path: remoteRoot, cleanup } = await createManagedTempRoot('wp-typia-template-source-');
+    const checkoutDir = path.join(remoteRoot, 'source');
+    try {
+        cloneGitHubTemplateSource(locator, checkoutDir);
+        const sourceDir = resolveGitHubTemplateDirectory(checkoutDir, locator);
         await assertNoSymlinks(sourceDir);
         return {
             blockDir: sourceDir,

package/dist/runtime/version-floor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Parse a dotted version floor into numeric parts for stable comparisons.
+ *
+ * @param value Human-authored version floor such as `7.0` or `8.1.2`.
+ * @returns Numeric version segments suitable for ordered comparison.
+ * @throws When any segment contains non-digit characters.
+ */
+export declare function parseVersionFloorParts(value: string): number[];
+/**
+ * Compare two dotted version floors.
+ *
+ * Missing trailing segments are treated as zero so `7.0` equals `7.0.0`.
+ *
+ * @param left Left-hand version floor.
+ * @param right Right-hand version floor.
+ * @returns `1` when left is higher, `-1` when right is higher, or `0` when equal.
+ */
+export declare function compareVersionFloors(left: string, right: string): number;
+/**
+ * Pick the higher version floor while tolerating undefined values.
+ *
+ * @param current Current resolved floor, when present.
+ * @param candidate Candidate floor to compare against the current floor.
+ * @returns The higher defined floor, or undefined when neither value exists.
+ */
+export declare function pickHigherVersionFloor(current: string | undefined, candidate: string | undefined): string | undefined;

package/dist/runtime/version-floor.js

@@ -0,0 +1,56 @@
+/**
+ * Parse a dotted version floor into numeric parts for stable comparisons.
+ *
+ * @param value Human-authored version floor such as `7.0` or `8.1.2`.
+ * @returns Numeric version segments suitable for ordered comparison.
+ * @throws When any segment contains non-digit characters.
+ */
+export function parseVersionFloorParts(value) {
+    return value.split('.').map((part, index) => {
+        if (!/^\d+$/u.test(part)) {
+            throw new Error(`parseVersionFloorParts received an invalid version floor "${value}" at segment ${index + 1}.`);
+        }
+        return Number.parseInt(part, 10);
+    });
+}
+/**
+ * Compare two dotted version floors.
+ *
+ * Missing trailing segments are treated as zero so `7.0` equals `7.0.0`.
+ *
+ * @param left Left-hand version floor.
+ * @param right Right-hand version floor.
+ * @returns `1` when left is higher, `-1` when right is higher, or `0` when equal.
+ */
+export function compareVersionFloors(left, right) {
+    const leftParts = parseVersionFloorParts(left);
+    const rightParts = parseVersionFloorParts(right);
+    const length = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftValue = leftParts[index] ?? 0;
+        const rightValue = rightParts[index] ?? 0;
+        if (leftValue > rightValue) {
+            return 1;
+        }
+        if (leftValue < rightValue) {
+            return -1;
+        }
+    }
+    return 0;
+}
+/**
+ * Pick the higher version floor while tolerating undefined values.
+ *
+ * @param current Current resolved floor, when present.
+ * @param candidate Candidate floor to compare against the current floor.
+ * @returns The higher defined floor, or undefined when neither value exists.
+ */
+export function pickHigherVersionFloor(current, candidate) {
+    if (!candidate) {
+        return current;
+    }
+    if (!current) {
+        return candidate;
+    }
+    return compareVersionFloors(current, candidate) >= 0 ? current : candidate;
+}

package/dist/runtime/workspace-inventory.d.ts

@@ -10,11 +10,25 @@ export interface WorkspaceVariationInventoryEntry {
     file: string;
     slug: string;
 }
+export interface WorkspaceBlockStyleInventoryEntry {
+    block: string;
+    file: string;
+    slug: string;
+}
+export interface WorkspaceBlockTransformInventoryEntry {
+    block: string;
+    file: string;
+    from: string;
+    slug: string;
+    to: string;
+}
 export interface WorkspacePatternInventoryEntry {
     file: string;
     slug: string;
 }
 export interface WorkspaceBindingSourceInventoryEntry {
+    attribute?: string;
+    block?: string;
     editorFile: string;
     serverFile: string;
     slug: string;
@@ -76,6 +90,21 @@ export interface WorkspaceAiFeatureInventoryEntry {
     typesFile: string;
     validatorsFile: string;
 }
+/**
+ * DataViews admin-screen entry parsed from `scripts/block-config.ts`.
+ *
+ * @property file Relative path to the generated admin view shared entry file.
+ * @property phpFile Relative path to the generated WordPress admin page glue.
+ * @property slug Normalized admin view slug.
+ * @property source Optional source locator such as `rest-resource:products` or
+ * `core-data:postType/post`.
+ */
+export interface WorkspaceAdminViewInventoryEntry {
+    file: string;
+    phpFile: string;
+    slug: string;
+    source?: string;
+}
 /**
  * Editor-plugin entry parsed from `scripts/block-config.ts`.
  *
@@ -89,14 +118,20 @@ export interface WorkspaceEditorPluginInventoryEntry {
     slot: string;
 }
 export interface WorkspaceInventory {
+    adminViews: WorkspaceAdminViewInventoryEntry[];
     bindingSources: WorkspaceBindingSourceInventoryEntry[];
     blockConfigPath: string;
     blocks: WorkspaceBlockInventoryEntry[];
+    blockStyles: WorkspaceBlockStyleInventoryEntry[];
+    blockTransforms: WorkspaceBlockTransformInventoryEntry[];
     abilities: WorkspaceAbilityInventoryEntry[];
     aiFeatures: WorkspaceAiFeatureInventoryEntry[];
     hasAbilitiesSection: boolean;
+    hasAdminViewsSection: boolean;
     hasBindingSourcesSection: boolean;
     hasAiFeaturesSection: boolean;
+    hasBlockStylesSection: boolean;
+    hasBlockTransformsSection: boolean;
     hasEditorPluginsSection: boolean;
     hasPatternsSection: boolean;
     hasRestResourcesSection: boolean;
@@ -109,11 +144,14 @@ export interface WorkspaceInventory {
 }
 export declare const BLOCK_CONFIG_ENTRY_MARKER = "\t// wp-typia add block entries";
 export declare const VARIATION_CONFIG_ENTRY_MARKER = "\t// wp-typia add variation entries";
+export declare const BLOCK_STYLE_CONFIG_ENTRY_MARKER = "\t// wp-typia add style entries";
+export declare const BLOCK_TRANSFORM_CONFIG_ENTRY_MARKER = "\t// wp-typia add transform entries";
 export declare const PATTERN_CONFIG_ENTRY_MARKER = "\t// wp-typia add pattern entries";
 export declare const BINDING_SOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add binding-source entries";
 export declare const REST_RESOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add rest-resource entries";
 export declare const ABILITY_CONFIG_ENTRY_MARKER = "\t// wp-typia add ability entries";
 export declare const AI_FEATURE_CONFIG_ENTRY_MARKER = "\t// wp-typia add ai-feature entries";
+export declare const ADMIN_VIEW_CONFIG_ENTRY_MARKER = "\t// wp-typia add admin-view entries";
 /**
  * Marker used to append generated editor-plugin entries into `EDITOR_PLUGINS`.
  */
@@ -152,7 +190,8 @@ export declare function getWorkspaceBlockSelectOptions(projectDir: string): Arra
  * Update `scripts/block-config.ts` source text with additional inventory entries.
  *
  * Missing inventory sections for variations, patterns, binding sources, REST
- * resources, workflow abilities, AI features, and editor plugins are created
+ * resources, workflow abilities, AI features, editor plugins, block styles, and
+ * block transforms are created
  * automatically before new entries are appended at their marker comments.
  * When provided, `transformSource` runs before any entries are inserted.
  *
@@ -160,10 +199,13 @@ export declare function getWorkspaceBlockSelectOptions(projectDir: string): Arra
  * @param options Entry lists plus an optional source transformer.
  * @returns Updated source text with all requested inventory entries appended.
  */
-export declare function updateWorkspaceInventorySource(source: string, { blockEntries, bindingSourceEntries, abilityEntries, aiFeatureEntries, editorPluginEntries, patternEntries, restResourceEntries, variationEntries, transformSource, }?: {
+export declare function updateWorkspaceInventorySource(source: string, { blockEntries, blockStyleEntries, blockTransformEntries, bindingSourceEntries, abilityEntries, adminViewEntries, aiFeatureEntries, editorPluginEntries, patternEntries, restResourceEntries, variationEntries, transformSource, }?: {
     abilityEntries?: string[];
+    adminViewEntries?: string[];
     aiFeatureEntries?: string[];
     blockEntries?: string[];
+    blockStyleEntries?: string[];
+    blockTransformEntries?: string[];
     bindingSourceEntries?: string[];
     editorPluginEntries?: string[];
     patternEntries?: string[];