@wp-typia/project-tools 0.24.3 → 0.24.5

package/dist/runtime/block-generator-tool-contract.js

@@ -1,157 +1 @@
-import { buildBuiltInBlockArtifacts, stringifyBuiltInBlockJsonDocument, } from "./built-in-block-artifacts.js";
-import { buildBuiltInCodeArtifacts, } from "./built-in-block-code-artifacts.js";
-import { BlockGeneratorService, } from "./block-generator-service.js";
-import { getStarterManifestFiles, stringifyStarterManifest, } from "./starter-manifests.js";
-import { listInterpolatedDirectoryOutputs } from "./template-render.js";
-/**
- * Semantic version marker for the public block generation tool contract.
- *
- * Increment this number whenever the serialized inspection payload changes in a
- * breaking way.
- */
-export const BLOCK_GENERATION_TOOL_CONTRACT_VERSION = 1;
-function buildStarterManifestPreviews(templateId, variables, artifacts) {
-    const starterManifests = getStarterManifestFiles(templateId, variables);
-    const artifactManifests = new Map(artifacts.map((artifact) => [
-        `${artifact.relativeDir}/typia.manifest.json`,
-        artifact.manifestDocument,
-    ]));
-    return starterManifests
-        .map((entry) => {
-        const document = artifactManifests.get(entry.relativePath) ?? entry.document;
-        return {
-            document,
-            owner: "emitter",
-            relativePath: entry.relativePath,
-            source: stringifyStarterManifest(document),
-        };
-    })
-        .sort((left, right) => left.relativePath.localeCompare(right.relativePath));
-}
-function buildStructuralArtifactPreviews(artifacts) {
-    return artifacts
-        .flatMap((artifact) => [
-        {
-            kind: "structural",
-            owner: "emitter",
-            relativePath: `${artifact.relativeDir}/block.json`,
-            source: stringifyBuiltInBlockJsonDocument(artifact.blockJsonDocument),
-        },
-        {
-            kind: "structural",
-            owner: "emitter",
-            relativePath: `${artifact.relativeDir}/types.ts`,
-            source: artifact.typesSource,
-        },
-    ])
-        .sort((left, right) => left.relativePath.localeCompare(right.relativePath));
-}
-function buildCodeArtifactPreviews(codeArtifacts) {
-    return codeArtifacts
-        .map((artifact) => ({
-        kind: "generated-source",
-        owner: "emitter",
-        relativePath: artifact.relativePath,
-        source: artifact.source,
-    }))
-        .sort((left, right) => left.relativePath.localeCompare(right.relativePath));
-}
-async function buildRenderPreview(rendered) {
-    const artifacts = buildBuiltInBlockArtifacts({
-        templateId: rendered.spec.template.family,
-        variables: rendered.variables,
-    });
-    const codeArtifacts = buildBuiltInCodeArtifacts({
-        templateId: rendered.spec.template.family,
-        variables: rendered.variables,
-    });
-    const copiedTemplateFiles = await listInterpolatedDirectoryOutputs(rendered.templateDir, rendered.variables);
-    return {
-        copiedTemplateFiles: copiedTemplateFiles.map((relativePath) => ({
-            owner: "template-copy",
-            relativePath,
-        })),
-        emittedFiles: [
-            ...buildStructuralArtifactPreviews(artifacts),
-            ...buildCodeArtifactPreviews(codeArtifacts),
-        ].sort((left, right) => left.relativePath.localeCompare(right.relativePath)),
-        gitignoreContent: rendered.gitignoreContent,
-        postRender: {
-            ...rendered.postRender,
-            installsDependencies: !rendered.target.noInstall,
-        },
-        readmeContent: rendered.readmeContent,
-        selectedVariant: rendered.selectedVariant,
-        starterManifestFiles: buildStarterManifestPreviews(rendered.spec.template.family, rendered.variables, artifacts),
-        template: {
-            description: rendered.spec.template.description,
-            family: rendered.spec.template.family,
-            features: [...rendered.spec.template.features],
-            format: "wp-typia",
-        },
-        warnings: [...rendered.warnings],
-    };
-}
-/**
- * Inspects built-in block generation through the staged generator boundary
- * without mutating the destination workspace.
- *
- * Use `stopAfter` to halt after the `plan`, `validate`, or `render` stage.
- * The render stage includes copied template file paths, emitter-owned source
- * previews, starter manifest previews, and post-render intent metadata. Any
- * temporary render state is cleaned up before the promise resolves.
- *
- * @example
- * ```ts
- * const inspection = await inspectBlockGeneration({
- * 	answers,
- * 	noInstall: true,
- * 	packageManager: "bun",
- * 	projectDir: "demo-block",
- * 	templateId: "basic",
- * 	stopAfter: "render",
- * });
- * ```
- *
- * @param input - Planning input plus an optional `stopAfter` stage selector.
- * @param service - Optional generator service instance. Defaults to a new
- * `BlockGeneratorService`.
- * @returns The serialized inspection result for the reached stage.
- * @throws Propagates planning, validation, or render failures from
- * `BlockGeneratorService`.
- */
-export async function inspectBlockGeneration({ stopAfter = "render", ...planInput }, service = new BlockGeneratorService()) {
-    const plan = await service.plan(planInput);
-    if (stopAfter === "plan") {
-        return {
-            contractVersion: BLOCK_GENERATION_TOOL_CONTRACT_VERSION,
-            mutatesWorkspace: false,
-            plan,
-            stage: "plan",
-        };
-    }
-    const validated = await service.validate({ plan });
-    if (stopAfter === "validate") {
-        return {
-            contractVersion: BLOCK_GENERATION_TOOL_CONTRACT_VERSION,
-            mutatesWorkspace: false,
-            plan,
-            stage: "validate",
-            validated,
-        };
-    }
-    const rendered = await service.render({ validated });
-    try {
-        return {
-            contractVersion: BLOCK_GENERATION_TOOL_CONTRACT_VERSION,
-            mutatesWorkspace: false,
-            plan,
-            rendered: await buildRenderPreview(rendered),
-            stage: "render",
-            validated,
-        };
-    }
-    finally {
-        await rendered.cleanup?.();
-    }
-}
+export * from "./templates/block-generator-tool-contract.js";

package/dist/runtime/block-targets.d.ts

@@ -1,40 +1 @@
-export interface WorkspaceBlockTargetName {
-    blockName: string;
-    blockSlug: string;
-}
-export interface WorkspaceBlockTargetDiagnostics {
-    empty: () => string;
-    emptySegment: (input: string) => string;
-    invalidFormat: (input: string) => string;
-    namespaceMismatch: (input: string, actualNamespace: string, expectedNamespace: string) => string;
-}
-/**
- * Validate a full `namespace/block-slug` block name.
- *
- * @param blockName Candidate block name.
- * @param flagName CLI flag name used in diagnostics.
- * @returns The trimmed full block name.
- * @throws {Error} When the block name is empty or not a full block name.
- */
-export declare function assertFullBlockName(blockName: string, flagName: string): string;
-/**
- * Resolve a workspace block target from either `block-slug` or
- * `namespace/block-slug` input while preserving caller-owned diagnostics.
- *
- * @param blockName Candidate block target.
- * @param namespace Expected workspace namespace.
- * @param diagnostics Error message builders for the caller's UX context.
- * @returns The normalized workspace block target.
- * @throws {Error} When the target is empty, malformed, or references another namespace.
- */
-export declare function resolveWorkspaceBlockTargetName(blockName: string, namespace: string, diagnostics: WorkspaceBlockTargetDiagnostics): WorkspaceBlockTargetName;
-/**
- * Resolve the standard `--to` style workspace block target used by add flows.
- *
- * @param blockName Candidate block target.
- * @param namespace Expected workspace namespace.
- * @param flagName CLI flag name used in diagnostics.
- * @returns The normalized workspace block target.
- * @throws {Error} When the target is empty, malformed, or references another namespace.
- */
-export declare function resolveWorkspaceTargetBlockName(blockName: string, namespace: string, flagName: string): WorkspaceBlockTargetName;
+export * from "./add/block-targets.js";

package/dist/runtime/block-targets.js

@@ -1,71 +1 @@
-import { normalizeBlockSlug } from "./scaffold-identifiers.js";
-const FULL_BLOCK_NAME_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
-/**
- * Validate a full `namespace/block-slug` block name.
- *
- * @param blockName Candidate block name.
- * @param flagName CLI flag name used in diagnostics.
- * @returns The trimmed full block name.
- * @throws {Error} When the block name is empty or not a full block name.
- */
-export function assertFullBlockName(blockName, flagName) {
-    const trimmed = blockName.trim();
-    if (!trimmed) {
-        throw new Error(`\`${flagName}\` requires a block name.`);
-    }
-    if (!FULL_BLOCK_NAME_PATTERN.test(trimmed)) {
-        throw new Error(`\`${flagName}\` must use <namespace/block-slug> format.`);
-    }
-    return trimmed;
-}
-/**
- * Resolve a workspace block target from either `block-slug` or
- * `namespace/block-slug` input while preserving caller-owned diagnostics.
- *
- * @param blockName Candidate block target.
- * @param namespace Expected workspace namespace.
- * @param diagnostics Error message builders for the caller's UX context.
- * @returns The normalized workspace block target.
- * @throws {Error} When the target is empty, malformed, or references another namespace.
- */
-export function resolveWorkspaceBlockTargetName(blockName, namespace, diagnostics) {
-    const trimmed = blockName.trim();
-    if (!trimmed) {
-        throw new Error(diagnostics.empty());
-    }
-    const blockNameSegments = trimmed.split("/");
-    if (blockNameSegments.length > 2) {
-        throw new Error(diagnostics.invalidFormat(trimmed));
-    }
-    if (blockNameSegments.some((segment) => segment.trim() === "")) {
-        throw new Error(diagnostics.emptySegment(trimmed));
-    }
-    const [maybeNamespace, maybeSlug] = blockNameSegments.length === 2
-        ? blockNameSegments
-        : [undefined, blockNameSegments[0]];
-    if (maybeNamespace && maybeNamespace !== namespace) {
-        throw new Error(diagnostics.namespaceMismatch(trimmed, maybeNamespace, namespace));
-    }
-    const blockSlug = normalizeBlockSlug(maybeSlug ?? "");
-    return {
-        blockName: `${namespace}/${blockSlug}`,
-        blockSlug,
-    };
-}
-/**
- * Resolve the standard `--to` style workspace block target used by add flows.
- *
- * @param blockName Candidate block target.
- * @param namespace Expected workspace namespace.
- * @param flagName CLI flag name used in diagnostics.
- * @returns The normalized workspace block target.
- * @throws {Error} When the target is empty, malformed, or references another namespace.
- */
-export function resolveWorkspaceTargetBlockName(blockName, namespace, flagName) {
-    return resolveWorkspaceBlockTargetName(blockName, namespace, {
-        empty: () => `\`${flagName}\` requires <block-slug|namespace/block-slug>.`,
-        emptySegment: () => `\`${flagName}\` must use <block-slug|namespace/block-slug> format.`,
-        invalidFormat: () => `\`${flagName}\` must use <block-slug|namespace/block-slug> format.`,
-        namespaceMismatch: (_input, actualNamespace, expectedNamespace) => `\`${flagName}\` references namespace "${actualNamespace}". Expected "${expectedNamespace}".`,
-    });
-}
+export * from "./add/block-targets.js";

package/dist/runtime/built-in-block-artifact-documents.d.ts

@@ -1,3 +1 @@
-export { DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER, buildBlockJsonAttributes, buildManifestDocument, } from "./built-in-block-attribute-emitters.js";
-export type { AttributeDescription, EmittedAttributeDefinition, } from "./built-in-block-attribute-emitters.js";
-export { buildBasicAttributes, buildCompoundChildAttributes, buildCompoundParentAttributes, buildInteractivityAttributes, buildPersistenceAttributes, } from "./built-in-block-attribute-specs.js";
+export * from "./templates/built-in-block-artifact-documents.js";

package/dist/runtime/built-in-block-artifact-documents.js

@@ -1,2 +1 @@
-export { DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER, buildBlockJsonAttributes, buildManifestDocument, } from "./built-in-block-attribute-emitters.js";
-export { buildBasicAttributes, buildCompoundChildAttributes, buildCompoundParentAttributes, buildInteractivityAttributes, buildPersistenceAttributes, } from "./built-in-block-attribute-specs.js";
+export * from "./templates/built-in-block-artifact-documents.js";

package/dist/runtime/built-in-block-artifact-types.d.ts

@@ -1,51 +1 @@
-import type { ScaffoldTemplateVariables } from "./scaffold.js";
-interface AttributeDescription {
-    lines: string[];
-}
-interface EmittedAttributeDefinition {
-    description?: AttributeDescription;
-    name: string;
-    optional: boolean;
-    typeExpression: string;
-}
-/**
- * Builds the generated attributes and validation type source for a basic block scaffold.
- *
- * @param variables Resolved scaffold template variables used to name emitted types.
- * @param attributes Emitted built-in attribute definitions that drive the interface members.
- * @returns TypeScript source for the basic block attribute and validation types.
- */
-export declare function buildBasicTypesSource(variables: ScaffoldTemplateVariables, attributes: readonly EmittedAttributeDefinition[]): string;
-/**
- * Builds the generated attributes, context, and validation type source for an interactivity scaffold.
- *
- * @param variables Resolved scaffold template variables used to name emitted types.
- * @param attributes Emitted built-in attribute definitions that drive the interface members.
- * @returns TypeScript source for the interactivity block attribute, context, and validation types.
- */
-export declare function buildInteractivityTypesSource(variables: ScaffoldTemplateVariables, attributes: readonly EmittedAttributeDefinition[]): string;
-/**
- * Builds the generated attributes, context, state, client, and validation type source for a persistence scaffold.
- *
- * @param variables Resolved scaffold template variables used to name emitted types.
- * @param attributes Emitted built-in attribute definitions that drive the interface members.
- * @returns TypeScript source for the persistence block runtime types.
- */
-export declare function buildPersistenceTypesSource(variables: ScaffoldTemplateVariables, attributes: readonly EmittedAttributeDefinition[]): string;
-/**
- * Builds the generated attributes and optional persistence runtime type source for a compound parent scaffold.
- *
- * @param variables Resolved scaffold template variables used to name emitted types.
- * @param attributes Emitted built-in attribute definitions that drive the interface members.
- * @returns TypeScript source for the compound parent runtime types.
- */
-export declare function buildCompoundTypesSource(variables: ScaffoldTemplateVariables, attributes: readonly EmittedAttributeDefinition[]): string;
-/**
- * Builds the generated attributes and validation type source for a compound child scaffold.
- *
- * @param variables Resolved scaffold template variables used to name emitted types.
- * @param attributes Emitted built-in attribute definitions that drive the interface members.
- * @returns TypeScript source for the compound child attribute and validation types.
- */
-export declare function buildCompoundChildTypesSource(variables: ScaffoldTemplateVariables, attributes: readonly EmittedAttributeDefinition[]): string;
-export {};
+export * from "./templates/built-in-block-artifact-types.js";

package/dist/runtime/built-in-block-artifact-types.js

@@ -1,316 +1 @@
-import { isCompoundPersistenceEnabled } from "./scaffold-template-variable-groups.js";
-const STANDARD_PREAMBLE_LINES = [
-    'import type { TextAlignment } from "@wp-typia/block-types/block-editor/alignment";',
-    "import type {",
-    "\tTypiaValidationError,",
-    "\tValidationResult,",
-    '} from "@wp-typia/block-runtime/validation";',
-    'import { tags } from "typia";',
-    "",
-    'export type { TypiaValidationError, ValidationResult } from "@wp-typia/block-runtime/validation";',
-];
-const VALIDATION_ONLY_PREAMBLE_LINES = [
-    'import type { ValidationResult } from "@wp-typia/block-runtime/validation";',
-    'import { tags } from "typia";',
-    "",
-    'export type { ValidationResult } from "@wp-typia/block-runtime/validation";',
-];
-function emitDocComment(description, indent = "") {
-    if (!description) {
-        return [];
-    }
-    return [
-        `${indent}/**`,
-        ...description.lines.map((line) => line.length === 0 ? `${indent} *` : `${indent} * ${line}`),
-        `${indent} */`,
-    ];
-}
-function emitInterface(definition) {
-    const lines = [
-        ...emitDocComment(definition.description),
-        `export interface ${definition.name} {`,
-    ];
-    for (const member of definition.members) {
-        lines.push(...emitDocComment(member.description, "\t"));
-        lines.push(`\t${member.name}${member.optional ? "?" : ""}: ${member.typeExpression};`);
-    }
-    lines.push("}");
-    return lines;
-}
-function emitTypesModule({ preambleLines, interfaces, typeAliases, }) {
-    const sections = [];
-    if (preambleLines.length > 0) {
-        sections.push(preambleLines.join("\n"));
-    }
-    for (const definition of interfaces) {
-        sections.push(emitInterface(definition).join("\n"));
-    }
-    if (typeAliases.length > 0) {
-        sections.push(typeAliases
-            .map((alias) => `export type ${alias.name} = ${alias.value};`)
-            .join("\n"));
-    }
-    return `${sections.join("\n\n")}\n`;
-}
-/**
- * Builds the generated attributes and validation type source for a basic block scaffold.
- *
- * @param variables Resolved scaffold template variables used to name emitted types.
- * @param attributes Emitted built-in attribute definitions that drive the interface members.
- * @returns TypeScript source for the basic block attribute and validation types.
- */
-export function buildBasicTypesSource(variables, attributes) {
-    return emitTypesModule({
-        preambleLines: [...STANDARD_PREAMBLE_LINES],
-        interfaces: [
-            {
-                description: {
-                    lines: [
-                        "Block attributes interface",
-                        "Typia tags define runtime validation rules",
-                    ],
-                },
-                members: attributes.map((attribute) => ({
-                    description: attribute.description,
-                    name: attribute.name,
-                    optional: attribute.optional,
-                    typeExpression: attribute.typeExpression,
-                })),
-                name: `${variables.pascalCase}Attributes`,
-            },
-        ],
-        typeAliases: [
-            {
-                name: `${variables.pascalCase}ValidationResult`,
-                value: `ValidationResult<${variables.pascalCase}Attributes>`,
-            },
-        ],
-    });
-}
-/**
- * Builds the generated attributes, context, and validation type source for an interactivity scaffold.
- *
- * @param variables Resolved scaffold template variables used to name emitted types.
- * @param attributes Emitted built-in attribute definitions that drive the interface members.
- * @returns TypeScript source for the interactivity block attribute, context, and validation types.
- */
-export function buildInteractivityTypesSource(variables, attributes) {
-    return emitTypesModule({
-        preambleLines: [...STANDARD_PREAMBLE_LINES],
-        interfaces: [
-            {
-                members: attributes.map((attribute) => ({
-                    name: attribute.name,
-                    optional: attribute.optional,
-                    typeExpression: attribute.typeExpression,
-                })),
-                name: `${variables.pascalCase}Attributes`,
-            },
-            {
-                members: [
-                    { name: "clicks", typeExpression: "number" },
-                    { name: "isAnimating", typeExpression: "boolean" },
-                    { name: "isVisible", typeExpression: "boolean" },
-                    {
-                        name: "animation",
-                        typeExpression: '"none" | "bounce" | "pulse" | "shake" | "flip"',
-                    },
-                    { name: "maxClicks", typeExpression: "number" },
-                ],
-                name: `${variables.pascalCase}Context`,
-            },
-            {
-                members: [
-                    { name: "clicks", typeExpression: "number" },
-                    { name: "isAnimating", typeExpression: "boolean" },
-                    { name: "isVisible", typeExpression: "boolean" },
-                    { name: "progress", typeExpression: "number" },
-                    { name: "clampedClicks", typeExpression: "number" },
-                    { name: "isComplete", typeExpression: "boolean" },
-                ],
-                name: `${variables.pascalCase}State`,
-            },
-        ],
-        typeAliases: [
-            {
-                name: `${variables.pascalCase}ValidationResult`,
-                value: `ValidationResult<${variables.pascalCase}Attributes>`,
-            },
-        ],
-    });
-}
-/**
- * Builds the generated attributes, context, state, client, and validation type source for a persistence scaffold.
- *
- * @param variables Resolved scaffold template variables used to name emitted types.
- * @param attributes Emitted built-in attribute definitions that drive the interface members.
- * @returns TypeScript source for the persistence block runtime types.
- */
-export function buildPersistenceTypesSource(variables, attributes) {
-    return emitTypesModule({
-        preambleLines: [...STANDARD_PREAMBLE_LINES],
-        interfaces: [
-            {
-                members: attributes.map((attribute) => ({
-                    name: attribute.name,
-                    optional: attribute.optional,
-                    typeExpression: attribute.typeExpression,
-                })),
-                name: `${variables.pascalCase}Attributes`,
-            },
-            {
-                members: [
-                    { name: "buttonLabel", typeExpression: "string" },
-                    { name: "bootstrapReady", typeExpression: "boolean" },
-                    { name: "canWrite", typeExpression: "boolean" },
-                    { name: "count", typeExpression: "number" },
-                    { name: "error", typeExpression: "string" },
-                    { name: "isBootstrapping", typeExpression: "boolean" },
-                    { name: "isLoading", typeExpression: "boolean" },
-                    { name: "isSaving", typeExpression: "boolean" },
-                    {
-                        name: "persistencePolicy",
-                        typeExpression: '"authenticated" | "public"',
-                    },
-                    { name: "postId", typeExpression: "number" },
-                    { name: "resourceKey", typeExpression: "string" },
-                    {
-                        name: "storage",
-                        typeExpression: '"post-meta" | "custom-table"',
-                    },
-                    { name: "isVisible", typeExpression: "boolean" },
-                    {
-                        name: "client",
-                        optional: true,
-                        typeExpression: `${variables.pascalCase}ClientState`,
-                    },
-                ],
-                name: `${variables.pascalCase}Context`,
-            },
-            {
-                members: [{ name: "isHydrated", typeExpression: "boolean" }],
-                name: `${variables.pascalCase}State`,
-            },
-            {
-                members: [
-                    { name: "bootstrapError", typeExpression: "string" },
-                    { name: "writeExpiry", typeExpression: "number" },
-                    { name: "writeNonce", typeExpression: "string" },
-                    { name: "writeToken", typeExpression: "string" },
-                ],
-                name: `${variables.pascalCase}ClientState`,
-            },
-        ],
-        typeAliases: [
-            {
-                name: `${variables.pascalCase}ValidationResult`,
-                value: `ValidationResult<${variables.pascalCase}Attributes>`,
-            },
-        ],
-    });
-}
-/**
- * Builds the generated attributes and optional persistence runtime type source for a compound parent scaffold.
- *
- * @param variables Resolved scaffold template variables used to name emitted types.
- * @param attributes Emitted built-in attribute definitions that drive the interface members.
- * @returns TypeScript source for the compound parent runtime types.
- */
-export function buildCompoundTypesSource(variables, attributes) {
-    const persistenceEnabled = isCompoundPersistenceEnabled(variables);
-    return emitTypesModule({
-        preambleLines: persistenceEnabled
-            ? [...STANDARD_PREAMBLE_LINES]
-            : [...VALIDATION_ONLY_PREAMBLE_LINES],
-        interfaces: [
-            {
-                members: attributes.map((attribute) => ({
-                    name: attribute.name,
-                    optional: attribute.optional,
-                    typeExpression: attribute.typeExpression,
-                })),
-                name: `${variables.pascalCase}Attributes`,
-            },
-            ...(persistenceEnabled
-                ? [
-                    {
-                        members: [
-                            { name: "buttonLabel", typeExpression: "string" },
-                            { name: "bootstrapReady", typeExpression: "boolean" },
-                            { name: "canWrite", typeExpression: "boolean" },
-                            { name: "count", typeExpression: "number" },
-                            { name: "error", typeExpression: "string" },
-                            { name: "isBootstrapping", typeExpression: "boolean" },
-                            { name: "isLoading", typeExpression: "boolean" },
-                            { name: "isSaving", typeExpression: "boolean" },
-                            {
-                                name: "persistencePolicy",
-                                typeExpression: '"authenticated" | "public"',
-                            },
-                            { name: "postId", typeExpression: "number" },
-                            { name: "resourceKey", typeExpression: "string" },
-                            { name: "showCount", typeExpression: "boolean" },
-                            {
-                                name: "storage",
-                                typeExpression: '"post-meta" | "custom-table"',
-                            },
-                            {
-                                name: "client",
-                                optional: true,
-                                typeExpression: `${variables.pascalCase}ClientState`,
-                            },
-                        ],
-                        name: `${variables.pascalCase}Context`,
-                    },
-                    {
-                        members: [{ name: "isHydrated", typeExpression: "boolean" }],
-                        name: `${variables.pascalCase}State`,
-                    },
-                    {
-                        members: [
-                            { name: "bootstrapError", typeExpression: "string" },
-                            { name: "writeExpiry", typeExpression: "number" },
-                            { name: "writeNonce", typeExpression: "string" },
-                            { name: "writeToken", typeExpression: "string" },
-                        ],
-                        name: `${variables.pascalCase}ClientState`,
-                    },
-                ]
-                : []),
-        ],
-        typeAliases: [
-            {
-                name: `${variables.pascalCase}ValidationResult`,
-                value: `ValidationResult<${variables.pascalCase}Attributes>`,
-            },
-        ],
-    });
-}
-/**
- * Builds the generated attributes and validation type source for a compound child scaffold.
- *
- * @param variables Resolved scaffold template variables used to name emitted types.
- * @param attributes Emitted built-in attribute definitions that drive the interface members.
- * @returns TypeScript source for the compound child attribute and validation types.
- */
-export function buildCompoundChildTypesSource(variables, attributes) {
-    return emitTypesModule({
-        preambleLines: [...VALIDATION_ONLY_PREAMBLE_LINES],
-        interfaces: [
-            {
-                members: attributes.map((attribute) => ({
-                    name: attribute.name,
-                    optional: attribute.optional,
-                    typeExpression: attribute.typeExpression,
-                })),
-                name: `${variables.pascalCase}ItemAttributes`,
-            },
-        ],
-        typeAliases: [
-            {
-                name: `${variables.pascalCase}ItemValidationResult`,
-                value: `ValidationResult<${variables.pascalCase}ItemAttributes>`,
-            },
-        ],
-    });
-}
+export * from "./templates/built-in-block-artifact-types.js";