@signstack/cli 0.1.1

package/dist/apps/signstack-cli/src/lib/payload-builder.d.ts

@@ -0,0 +1,127 @@
+import { type BlueprintResource, type ScenarioEntity, type RenderTemplateReq, type RenderBlueprintReq, type TemplateResource, type AssetResource, type SchemaResource, type JsonataFunctionResource, type CreateWorkflowReq, type CreateWorkflowMode, type ParsedDocument } from '@signstack/base';
+/** Asset file ready for upload */
+export interface AssetFilePayload {
+    assetKey: string;
+    assetVersion: string;
+    fileName: string;
+    contentType: string;
+    content: Buffer;
+    fileHash: string;
+    sizeBytes: number;
+}
+/**
+ * PayloadBuilder - Converts YAML documents to typed API payload format
+ *
+ * Transforms parsed YAML documents into the format expected by the
+ * render-inline API endpoint (matching BlueprintResp / TemplateResp).
+ */
+export declare class PayloadBuilder {
+    /**
+     * Build Blueprint payload from YAML
+     * Returns a BlueprintResource matching the unified RenderBlueprintReq shape
+     */
+    buildBlueprintPayload(doc: ParsedDocument): BlueprintResource;
+    /**
+     * Transform YAML participants to BlueprintParticipant[] (API shape).
+     */
+    private transformBlueprintParticipants;
+    /**
+     * Transform YAML orchestration tree to BlueprintStep tree (API shape).
+     * Normalizes action: YAML uses envelope/document/role → API uses envelopeKey/documentKey/roleKey.
+     */
+    private transformOrchestrationToTree;
+    /**
+     * Build RenderTemplateReq with inline resources from YAML documents.
+     * Ships resources as structured documents — no tree flattening.
+     */
+    buildRenderTemplateReq(params: {
+        templateDoc: ParsedDocument;
+        assetDocs: ParsedDocument[];
+        functionDocs?: ParsedDocument[];
+        schemaDocs?: ParsedDocument[];
+        fileIdMap?: Map<string, string>;
+        entities?: ScenarioEntity[];
+        inlineOnly?: boolean;
+        skipSignatureFields?: boolean;
+    }): RenderTemplateReq;
+    /**
+     * Build RenderBlueprintReq with inline resources from YAML documents.
+     */
+    buildRenderBlueprintReq(params: {
+        blueprintDoc: ParsedDocument;
+        templateDocs: ParsedDocument[];
+        assetDocs: ParsedDocument[];
+        functionDocs?: ParsedDocument[];
+        schemaDocs?: ParsedDocument[];
+        fileIdMap?: Map<string, string>;
+        entities?: ScenarioEntity[];
+        inlineOnly?: boolean;
+        skipSignatureFields?: boolean;
+        combinePdfs?: boolean;
+    }): RenderBlueprintReq;
+    /**
+     * Build CreateWorkflowReq with inline resources from YAML documents.
+     */
+    buildCreateWorkflowReq(params: {
+        blueprintDoc: ParsedDocument;
+        templateDocs: ParsedDocument[];
+        assetDocs: ParsedDocument[];
+        functionDocs?: ParsedDocument[];
+        schemaDocs?: ParsedDocument[];
+        fileIdMap?: Map<string, string>;
+        entities?: {
+            key: string;
+            data: Record<string, any>;
+        }[];
+        inlineOnly?: boolean;
+        mode?: CreateWorkflowMode;
+    }): CreateWorkflowReq;
+    /**
+     * Build a TemplateResource from a YAML template document.
+     */
+    buildTemplateResource(doc: ParsedDocument): TemplateResource;
+    /**
+     * Build an AssetResource from a YAML asset document.
+     * For text assets: reads file content. For binary assets: uses fileIdMap.
+     */
+    buildAssetResource(doc: ParsedDocument, fileIdMap?: Map<string, string>): AssetResource | null;
+    /**
+     * Build AssetHtmlConfigRefs from YAML spec.
+     * Maps YAML format (name→ref) to API format ({ key, version, name? }).
+     */
+    private buildAssetHtmlConfigRefs;
+    /**
+     * Build a JsonataFunctionResource from a YAML function document.
+     */
+    buildFunctionResource(doc: ParsedDocument): JsonataFunctionResource | null;
+    /**
+     * Build a SchemaResource from a YAML schema document.
+     */
+    buildSchemaResource(doc: ParsedDocument): SchemaResource | null;
+    /**
+     * Resolve a file path reference from a YAML document, with path-traversal protection.
+     *
+     * The resolved path must stay within the project root, defined as the parent of
+     * the directory containing the YAML file. This allows cross-subdirectory references
+     * (e.g., `schemas/foo.yaml` referencing `../definitions/foo.json`) while still
+     * preventing traversal outside the project.
+     *
+     * Returns null if the path resolves outside the project root.
+     */
+    private resolveFileRef;
+    /**
+     * Read asset file content as text (for HTML/CSS assets)
+     * Returns null if file not found or can't be read
+     */
+    readAssetFileContent(doc: ParsedDocument): string | null;
+    /**
+     * Build Asset file payload from YAML
+     * Returns file content ready for upload, or null if no file
+     */
+    buildAssetPayload(doc: ParsedDocument): AssetFilePayload | null;
+    /**
+     * Build Schema payload - reads the JSON definition file
+     * Returns the parsed document with definition loaded (for entity data generation)
+     */
+    buildSchemaPayload(doc: ParsedDocument): ParsedDocument;
+}

package/dist/apps/signstack-cli/src/lib/payload-builder.js

@@ -0,0 +1,545 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve, basename, sep } from 'node:path';
+import { createHash } from 'node:crypto';
+import { JsonataFunctionParamType, JsonataFunctionItemType, JsonSchemaDraft, } from '@signstack/base';
+import { extractBlueprintInputKey, getContentType, transformField, transformInputs, transformRole, normalizeExpression, normalizeYamlFunctions, } from './yaml-transforms.js';
+/**
+ * PayloadBuilder - Converts YAML documents to typed API payload format
+ *
+ * Transforms parsed YAML documents into the format expected by the
+ * render-inline API endpoint (matching BlueprintResp / TemplateResp).
+ */
+export class PayloadBuilder {
+    /**
+     * Build Blueprint payload from YAML
+     * Returns a BlueprintResource matching the unified RenderBlueprintReq shape
+     */
+    buildBlueprintPayload(doc) {
+        const spec = doc.content['spec'];
+        const meta = doc.content['metadata'];
+        const inputs = transformInputs(spec?.inputs ?? []);
+        const participants = this.transformBlueprintParticipants(spec?.participants ?? []);
+        const orchestration = spec?.orchestration
+            ? this.transformOrchestrationToTree(spec.orchestration)
+            : undefined;
+        const envelopes = (spec?.envelopes ?? []).map((env) => ({
+            key: env.key,
+            subject: env.subject ?? env.name ?? env.key,
+            documents: (env.documents ?? []).map((d) => {
+                const [templateKey, templateVersion] = (d.template ?? '').split('@');
+                const yamlInputMap = d.inputMap;
+                // Only send inputMap when explicitly specified in YAML.
+                // undefined → auto-map by matching keys; [] or populated → explicit mapping.
+                const inputMap = yamlInputMap
+                    ? Object.entries(yamlInputMap).map(([k, v]) => ({
+                        templateInputKey: k,
+                        blueprintInputKey: typeof v === 'string' ? extractBlueprintInputKey(v) : '',
+                    }))
+                    : undefined;
+                return {
+                    key: d.key,
+                    name: d.name ?? d.key,
+                    templateKey,
+                    templateVersion,
+                    inputMap,
+                    includeIf: d.includeIf,
+                    iterator: d.iterator,
+                    fileId: normalizeExpression(d.fileId),
+                };
+            }),
+        }));
+        const functions = normalizeYamlFunctions(spec?.functions);
+        return {
+            metadata: {
+                key: doc.key,
+                version: doc.version,
+                name: meta?.name ?? doc.key,
+                description: meta?.description,
+            },
+            spec: { envelopes, inputs, participants, orchestration, functions },
+        };
+    }
+    /**
+     * Transform YAML participants to BlueprintParticipant[] (API shape).
+     */
+    transformBlueprintParticipants(yamlParticipants) {
+        if (yamlParticipants.length === 0)
+            return undefined;
+        return yamlParticipants.map((p) => ({
+            key: p.key,
+            name: typeof p.name === 'string' ? p.name : p.key,
+            roleCategory: p.roleCategory,
+            participantName: p.name,
+            participantEmail: p.email,
+        }));
+    }
+    /**
+     * Transform YAML orchestration tree to BlueprintStep tree (API shape).
+     * Normalizes action: YAML uses envelope/document/role → API uses envelopeKey/documentKey/roleKey.
+     */
+    transformOrchestrationToTree(node) {
+        const rawAction = node.action;
+        if (node.type === 'group') {
+            const step = {
+                key: node.key,
+                type: node.type,
+                execution: node.execution === 'parallel' ? 'parallel' : 'sequential',
+                completion: node.completion === 'any'
+                    ? 'any'
+                    : node.completion === 'quorum'
+                        ? 'quorum'
+                        : 'all',
+                children: (node.children ?? []).map((c) => this.transformOrchestrationToTree(c)),
+            };
+            if (node.name)
+                step.name = node.name;
+            if (node.includeIf)
+                step.includeIf = node.includeIf;
+            if (node.quorum != null)
+                step.quorum = node.quorum;
+            if (node.onComplete)
+                step.onComplete = node.onComplete;
+            return step;
+        }
+        const step = {
+            key: node.key,
+            type: node.type,
+            participantKey: node.participant,
+        };
+        if (node.name)
+            step.name = node.name;
+        if (node.includeIf)
+            step.includeIf = node.includeIf;
+        if (node.onComplete)
+            step.onComplete = node.onComplete;
+        if (rawAction) {
+            step.action = {
+                type: (rawAction.type === 'sign' ? 'sign' : rawAction.type),
+                envelopeKey: rawAction.envelopeKey ?? rawAction.envelope ?? '',
+                assignments: (rawAction.assignments ?? []).map((a) => ({
+                    documentKey: a.documentKey ?? a.document ?? '',
+                    roleKey: a.roleKey ?? a.role ?? '',
+                })),
+            };
+        }
+        return step;
+    }
+    /**
+     * Build RenderTemplateReq with inline resources from YAML documents.
+     * Ships resources as structured documents — no tree flattening.
+     */
+    buildRenderTemplateReq(params) {
+        const { templateDoc, assetDocs, functionDocs, schemaDocs, fileIdMap, entities, inlineOnly, skipSignatureFields, } = params;
+        // Build template resource
+        const template = this.buildTemplateResource(templateDoc);
+        // Build asset resources
+        const assets = assetDocs
+            .map((doc) => this.buildAssetResource(doc, fileIdMap))
+            .filter((a) => a !== null);
+        // Build function resources
+        const functions = (functionDocs ?? [])
+            .map((doc) => this.buildFunctionResource(doc))
+            .filter((f) => f !== null);
+        // Build schema resources
+        const schemas = (schemaDocs ?? [])
+            .map((doc) => this.buildSchemaResource(doc))
+            .filter((s) => s !== null);
+        return {
+            inlineResources: {
+                template,
+                assets: assets.length > 0 ? assets : undefined,
+                functions: functions.length > 0 ? functions : undefined,
+                schemas: schemas.length > 0 ? schemas : undefined,
+                inlineOnly,
+            },
+            entities: entities?.length
+                ? entities.map((e) => ({
+                    inputKey: e.key,
+                    data: e.data,
+                }))
+                : undefined,
+            options: { skipSignatureFields },
+        };
+    }
+    /**
+     * Build RenderBlueprintReq with inline resources from YAML documents.
+     */
+    buildRenderBlueprintReq(params) {
+        const { blueprintDoc, templateDocs, assetDocs, functionDocs, schemaDocs, fileIdMap, entities, inlineOnly, skipSignatureFields, combinePdfs, } = params;
+        // Build blueprint resource
+        const blueprint = this.buildBlueprintPayload(blueprintDoc);
+        // Build template resources
+        const templates = templateDocs.map((doc) => this.buildTemplateResource(doc));
+        // Build asset resources
+        const assets = assetDocs
+            .map((doc) => this.buildAssetResource(doc, fileIdMap))
+            .filter((a) => a !== null);
+        // Build function resources
+        const functions = (functionDocs ?? [])
+            .map((doc) => this.buildFunctionResource(doc))
+            .filter((f) => f !== null);
+        // Build schema resources
+        const schemas = (schemaDocs ?? [])
+            .map((doc) => this.buildSchemaResource(doc))
+            .filter((s) => s !== null);
+        return {
+            inlineResources: {
+                blueprint,
+                templates: templates.length > 0 ? templates : undefined,
+                assets: assets.length > 0 ? assets : undefined,
+                functions: functions.length > 0 ? functions : undefined,
+                schemas: schemas.length > 0 ? schemas : undefined,
+            },
+            entities: entities?.length
+                ? entities.map((e) => ({
+                    inputKey: e.key,
+                    data: e.data,
+                }))
+                : undefined,
+            options: {
+                inlineOnly,
+                skipSignatureFields,
+                combinePdfs,
+            },
+        };
+    }
+    /**
+     * Build CreateWorkflowReq with inline resources from YAML documents.
+     */
+    buildCreateWorkflowReq(params) {
+        const { blueprintDoc, templateDocs, assetDocs, functionDocs, schemaDocs, fileIdMap, entities, inlineOnly, mode, } = params;
+        // Build blueprint resource
+        const blueprint = this.buildBlueprintPayload(blueprintDoc);
+        // Build template resources
+        const templates = templateDocs.map((doc) => this.buildTemplateResource(doc));
+        // Build asset resources
+        const assets = assetDocs
+            .map((doc) => this.buildAssetResource(doc, fileIdMap))
+            .filter((a) => a !== null);
+        // Build function resources
+        const functions = (functionDocs ?? [])
+            .map((doc) => this.buildFunctionResource(doc))
+            .filter((f) => f !== null);
+        // Build schema resources
+        const schemas = (schemaDocs ?? [])
+            .map((doc) => this.buildSchemaResource(doc))
+            .filter((s) => s !== null);
+        // Convert entities array to flat data map
+        const data = entities?.length
+            ? Object.fromEntries(entities.map((e) => [e.key, e.data]))
+            : undefined;
+        return {
+            inlineResources: {
+                blueprint,
+                templates: templates.length > 0 ? templates : undefined,
+                assets: assets.length > 0 ? assets : undefined,
+                functions: functions.length > 0 ? functions : undefined,
+                schemas: schemas.length > 0 ? schemas : undefined,
+            },
+            data,
+            options: mode || inlineOnly ? { mode, inlineOnly } : undefined,
+        };
+    }
+    /**
+     * Build a TemplateResource from a YAML template document.
+     */
+    buildTemplateResource(doc) {
+        const spec = doc.content['spec'];
+        const meta = doc.content['metadata'];
+        const [contentKey, contentVersion] = (spec?.content ?? '').split('@');
+        const fields = (spec?.fields ?? []).map((f) => transformField(f));
+        const inputs = transformInputs(spec?.inputs ?? []);
+        const roles = (spec?.roles ?? []).map((r) => transformRole(r));
+        const data = spec?.data?.transform
+            ? { transform: spec.data.transform }
+            : undefined;
+        const functions = normalizeYamlFunctions(spec?.functions);
+        return {
+            metadata: {
+                key: doc.key,
+                version: doc.version,
+                name: meta?.name ?? doc.key,
+                description: meta?.description,
+            },
+            spec: {
+                type: (spec?.type ?? 'pdf'),
+                contentKey,
+                contentVersion,
+                fields,
+                inputs,
+                roles,
+                data,
+                functions,
+            },
+        };
+    }
+    /**
+     * Build an AssetResource from a YAML asset document.
+     * For text assets: reads file content. For binary assets: uses fileIdMap.
+     */
+    buildAssetResource(doc, fileIdMap) {
+        const spec = doc.content['spec'];
+        const meta = doc.content['metadata'];
+        const assetType = spec?.['type'] ?? '';
+        // Text assets: read content from file
+        const isTextAsset = ['html', 'css', 'markdown'].includes(assetType);
+        let content;
+        let fileId;
+        if (isTextAsset) {
+            content = this.readAssetFileContent(doc) ?? undefined;
+            // Also check inline content from synthetic docs
+            if (!content &&
+                spec?.['content'] &&
+                typeof spec['content'] === 'string') {
+                content = spec['content'];
+            }
+        }
+        else {
+            // Binary assets: look up fileId
+            fileId = fileIdMap?.get(`${doc.key}@${doc.version}`);
+        }
+        // Build htmlConfig refs from YAML spec
+        const htmlConfig = this.buildAssetHtmlConfigRefs(spec);
+        return {
+            metadata: {
+                key: doc.key,
+                version: doc.version,
+                name: meta?.name ?? doc.key,
+                description: meta?.description,
+            },
+            spec: {
+                type: assetType,
+                content,
+                fileId,
+                htmlConfig: htmlConfig ?? undefined,
+            },
+        };
+    }
+    /**
+     * Build AssetHtmlConfigRefs from YAML spec.
+     * Maps YAML format (name→ref) to API format ({ key, version, name? }).
+     */
+    buildAssetHtmlConfigRefs(spec) {
+        if (!spec)
+            return null;
+        const yamlPartials = spec['partials'];
+        const yamlStyles = spec['styles'];
+        const yamlImages = spec['images'];
+        const dataSpec = spec['data'];
+        const schemaRef = dataSpec?.['schema'];
+        if (!yamlPartials && !yamlStyles && !yamlImages && !schemaRef) {
+            return null;
+        }
+        const partials = yamlPartials
+            ? Object.entries(yamlPartials).map(([alias, ref]) => {
+                const assetRef = typeof ref === 'string'
+                    ? ref
+                    : ref?.['asset'];
+                const [key, version] = (assetRef ?? '').split('@');
+                const roleMap = typeof ref === 'object'
+                    ? ref?.['roleMap']
+                    : undefined;
+                return { key, version, alias, ...(roleMap ? { roleMap } : {}) };
+            })
+            : undefined;
+        const styles = yamlStyles
+            ? yamlStyles.map((ref) => {
+                const [key, version] = ref.split('@');
+                return { key, version };
+            })
+            : undefined;
+        const images = yamlImages
+            ? Object.entries(yamlImages).map(([alias, ref]) => {
+                const [key, version] = ref.split('@');
+                return { key, version, alias };
+            })
+            : undefined;
+        let schemaKey;
+        let schemaVersion;
+        if (schemaRef) {
+            [schemaKey, schemaVersion] = schemaRef.split('@');
+        }
+        return {
+            partials: partials?.length ? partials : undefined,
+            styles: styles?.length ? styles : undefined,
+            images: images?.length ? images : undefined,
+            data: schemaKey ? { schemaKey, schemaVersion } : undefined,
+        };
+    }
+    /**
+     * Build a JsonataFunctionResource from a YAML function document.
+     */
+    buildFunctionResource(doc) {
+        const spec = doc.content['spec'];
+        const meta = doc.content['metadata'];
+        if (!spec?.['body'])
+            return null;
+        const yamlParams = spec['params'];
+        const params = yamlParams?.map((p) => {
+            const type = p.type;
+            const itemType = type === JsonataFunctionParamType.Array && p.itemType
+                ? p.itemType
+                : undefined;
+            const allowsSchema = type === JsonataFunctionParamType.Object ||
+                (type === JsonataFunctionParamType.Array &&
+                    itemType === JsonataFunctionItemType.Object);
+            const [schemaKey, schemaVersion] = (p.schema ?? '').split('@');
+            return {
+                name: p.name,
+                type,
+                ...(itemType ? { itemType } : {}),
+                ...(allowsSchema && schemaKey ? { schemaKey, schemaVersion } : {}),
+            };
+        });
+        const yamlReturn = spec['returnType'];
+        const returnTypeVal = (yamlReturn?.type ??
+            'string');
+        const returnItemType = returnTypeVal === JsonataFunctionParamType.Array && yamlReturn?.itemType
+            ? yamlReturn.itemType
+            : undefined;
+        const returnAllowsSchema = returnTypeVal === JsonataFunctionParamType.Object ||
+            (returnTypeVal === JsonataFunctionParamType.Array &&
+                returnItemType === JsonataFunctionItemType.Object);
+        const [returnSchemaKey, returnSchemaVersion] = (yamlReturn?.schema ?? '').split('@');
+        return {
+            metadata: {
+                key: doc.key,
+                version: doc.version,
+                name: meta?.name ?? doc.key,
+                description: meta?.description,
+            },
+            spec: {
+                params,
+                returnType: {
+                    type: returnTypeVal,
+                    ...(returnItemType ? { itemType: returnItemType } : {}),
+                    ...(returnAllowsSchema && returnSchemaKey
+                        ? { schemaKey: returnSchemaKey, schemaVersion: returnSchemaVersion }
+                        : {}),
+                },
+                body: spec['body'],
+            },
+        };
+    }
+    /**
+     * Build a SchemaResource from a YAML schema document.
+     */
+    buildSchemaResource(doc) {
+        const spec = doc.content['spec'];
+        const meta = doc.content['metadata'];
+        // The schema definition may have been loaded by buildSchemaPayload
+        const definition = spec?.['definition'];
+        if (!definition)
+            return null;
+        return {
+            metadata: {
+                key: doc.key,
+                version: doc.version,
+                name: meta?.name ?? doc.key,
+                description: meta?.description,
+            },
+            spec: {
+                jsonSchemaDraft: spec?.['jsonSchemaDraft'] ??
+                    JsonSchemaDraft.DRAFT_2020_12,
+                schemaDefinition: definition,
+            },
+        };
+    }
+    /**
+     * Resolve a file path reference from a YAML document, with path-traversal protection.
+     *
+     * The resolved path must stay within the project root, defined as the parent of
+     * the directory containing the YAML file. This allows cross-subdirectory references
+     * (e.g., `schemas/foo.yaml` referencing `../definitions/foo.json`) while still
+     * preventing traversal outside the project.
+     *
+     * Returns null if the path resolves outside the project root.
+     */
+    resolveFileRef(docFilePath, filePath) {
+        const yamlDir = resolve(dirname(docFilePath));
+        // Allow up to one level above the YAML's directory (the project root)
+        const projectRoot = resolve(yamlDir, '..') + sep;
+        const resolvedFilePath = resolve(yamlDir, filePath);
+        if (!resolvedFilePath.startsWith(projectRoot)) {
+            return null;
+        }
+        return resolvedFilePath;
+    }
+    /**
+     * Read asset file content as text (for HTML/CSS assets)
+     * Returns null if file not found or can't be read
+     */
+    readAssetFileContent(doc) {
+        const spec = doc.content['spec'];
+        const filePath = spec?.['file'];
+        // Handle synthetic documents with inline content from remote assets.
+        // These are created in `preview-handler.ts` for remote partials/styles in hybrid mode.
+        if (!filePath && spec?.content && typeof spec.content === 'string') {
+            return spec.content;
+        }
+        if (!filePath) {
+            return null;
+        }
+        const resolvedFilePath = this.resolveFileRef(doc.filePath, filePath);
+        if (!resolvedFilePath)
+            return null;
+        if (!existsSync(resolvedFilePath)) {
+            return null;
+        }
+        try {
+            return readFileSync(resolvedFilePath, 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Build Asset file payload from YAML
+     * Returns file content ready for upload, or null if no file
+     */
+    buildAssetPayload(doc) {
+        const spec = doc.content['spec'];
+        const filePath = spec?.['file'];
+        if (!filePath)
+            return null;
+        const resolvedFilePath = this.resolveFileRef(doc.filePath, filePath);
+        if (!resolvedFilePath)
+            return null;
+        if (!existsSync(resolvedFilePath))
+            return null;
+        const fileName = basename(resolvedFilePath);
+        const fileContent = readFileSync(resolvedFilePath);
+        return {
+            assetKey: doc.key,
+            assetVersion: doc.version,
+            fileName,
+            contentType: getContentType(resolvedFilePath),
+            content: fileContent,
+            fileHash: createHash('sha256').update(fileContent).digest('hex'),
+            sizeBytes: fileContent.length,
+        };
+    }
+    /**
+     * Build Schema payload - reads the JSON definition file
+     * Returns the parsed document with definition loaded (for entity data generation)
+     */
+    buildSchemaPayload(doc) {
+        const content = { ...doc.content };
+        const spec = content['spec'];
+        if (spec?.['file']) {
+            const filePath = spec['file'];
+            const resolvedFilePath = this.resolveFileRef(doc.filePath, filePath);
+            if (resolvedFilePath && existsSync(resolvedFilePath)) {
+                try {
+                    const fileContent = readFileSync(resolvedFilePath, 'utf-8');
+                    spec['definition'] = JSON.parse(fileContent);
+                }
+                catch {
+                    // If file can't be read/parsed, continue without it
+                }
+            }
+        }
+        return { ...doc, content };
+    }
+}
+//# sourceMappingURL=payload-builder.js.map