@bbigbang/core 0.1.0

package/dist/services/droidMissionImporter.js

@@ -0,0 +1,630 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+const JSON_FILES = [
+    'state.json',
+    'features.json',
+    'validation-state.json',
+    'model-settings.json',
+    'runtime-custom-models.json',
+];
+const SENSITIVE_KEY_RE = /(api[_-]?key|secret|token|password|authorization|credential|bearer)/i;
+const SECRET_VALUE_PATTERNS = [
+    /\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi,
+    /\b(?:sk|sk-ant|sk-proj|ghp|github_pat|xox[baprs])[-_A-Za-z0-9]{8,}\b/g,
+    /\b[A-Za-z0-9._%+-]+:[A-Za-z0-9._~+/=-]{12,}@/g,
+];
+const REPORT_TEXT_LIMIT = 120_000;
+const TRANSCRIPT_TEXT_LIMIT = 40_000;
+export function importDroidMissionArtifacts(missionDir, now = Date.now(), options = {}) {
+    if (!existsSync(missionDir) || !statSync(missionDir).isDirectory()) {
+        throw new Error(`Droid mission dir not found: ${missionDir}`);
+    }
+    const anomalies = [];
+    const state = readJsonObject(join(missionDir, 'state.json'), anomalies, false);
+    const featuresJson = readJsonObject(join(missionDir, 'features.json'), anomalies, false);
+    const validationJson = readJsonObject(join(missionDir, 'validation-state.json'), anomalies, false);
+    const modelSettings = readJsonObject(join(missionDir, 'model-settings.json'), anomalies, false);
+    const runtimeCustomModels = readJsonObject(join(missionDir, 'runtime-custom-models.json'), anomalies, true);
+    const timelineEvents = readJsonLines(join(missionDir, 'progress_log.jsonl'), anomalies);
+    const handoffItems = readHandoffs(join(missionDir, 'handoffs'), anomalies);
+    const featureItems = normalizeFeatures(featuresJson);
+    const assertions = normalizeValidationAssertions(validationJson);
+    const reports = readMarkdownReports(missionDir, anomalies);
+    const transcripts = readWorkerTranscripts(missionDir, anomalies);
+    const reportOnly = shouldUseReportOnlyMode(state, reports, options);
+    const artifactFiles = listArtifactFiles(missionDir, anomalies, { reportOnly });
+    const normalizedAnomalies = normalizeArtifactAnomalies(anomalies, missionDir, { reportOnly });
+    return {
+        schemaVersion: 1,
+        importedAt: now,
+        missionDir,
+        ...(options.platformMissionDir ? { platformMissionDir: options.platformMissionDir } : {}),
+        ...(options.factorySessionId ? { factorySessionId: options.factorySessionId } : {}),
+        overview: buildOverview(state, featureItems, timelineEvents, handoffItems, assertions, {
+            fallbackMissionId: options.fallbackMissionId,
+            fallbackState: options.fallbackState,
+            reportOnly,
+            reportCount: reports.length,
+        }),
+        features: {
+            summary: summarizeByStatusAndMilestone(featureItems),
+            items: featureItems,
+        },
+        timeline: {
+            summary: summarizeTimeline(timelineEvents),
+            events: timelineEvents,
+        },
+        handoffs: {
+            summary: summarizeHandoffs(handoffItems),
+            items: handoffItems,
+        },
+        validation: {
+            summary: summarizeValidation(assertions),
+            assertions,
+            raw: validationJson ? redactSecrets(validationJson) : undefined,
+        },
+        artifacts: {
+            files: artifactFiles,
+            reports,
+            transcripts,
+            diagnostics: summarizeAnomalies(normalizedAnomalies),
+        },
+        settings: {
+            modelSettings: modelSettings ? redactSecrets(modelSettings) : null,
+            runtimeCustomModels: runtimeCustomModels ? redactSecrets(runtimeCustomModels) : null,
+        },
+        anomalies: normalizedAnomalies,
+    };
+}
+function readWorkerTranscripts(missionDir, anomalies) {
+    const filePath = join(missionDir, 'worker-transcripts.jsonl');
+    if (!existsSync(filePath))
+        return [];
+    const lines = readFileSync(filePath, 'utf8').split(/\r?\n/);
+    const transcripts = [];
+    lines.forEach((line, index) => {
+        if (!line.trim())
+            return;
+        try {
+            const parsed = JSON.parse(line);
+            if (!isRecord(parsed)) {
+                anomalies.push({ severity: 'warning', type: 'invalid_jsonl_record', path: 'worker-transcripts.jsonl', line: index + 1 });
+                return;
+            }
+            const skeleton = stringValue(parsed.skeleton) ?? stringValue(parsed.transcript) ?? stringValue(parsed.text) ?? '';
+            const truncated = skeleton.length > TRANSCRIPT_TEXT_LIMIT;
+            const text = truncated ? `${skeleton.slice(0, TRANSCRIPT_TEXT_LIMIT)}\n[truncated]` : skeleton;
+            transcripts.push(redactSecrets({
+                lineNumber: index + 1,
+                featureId: stringValue(parsed.featureId),
+                milestone: stringValue(parsed.milestone),
+                workerSessionId: stringValue(parsed.workerSessionId),
+                role: inferTranscriptRole(parsed),
+                timestamp: stringValue(parsed.timestamp),
+                timestampMs: parseTimestamp(stringValue(parsed.timestamp)) ?? numberValue(parsed.timestampMs),
+                preview: firstMeaningfulLine(skeleton),
+                text,
+                truncated,
+                raw: transcriptMetadata(parsed, { textChars: skeleton.length, truncated }),
+            }));
+        }
+        catch (error) {
+            anomalies.push({
+                severity: 'warning',
+                type: 'invalid_jsonl',
+                path: 'worker-transcripts.jsonl',
+                line: index + 1,
+                message: String(error.message ?? error),
+            });
+        }
+    });
+    return transcripts.sort((left, right) => {
+        const leftTime = numberValue(left.timestampMs) ?? numberValue(left.lineNumber) ?? 0;
+        const rightTime = numberValue(right.timestampMs) ?? numberValue(right.lineNumber) ?? 0;
+        return leftTime - rightTime;
+    });
+}
+function transcriptMetadata(record, details) {
+    const raw = {};
+    for (const [key, value] of Object.entries(record)) {
+        if (key === 'skeleton' || key === 'transcript' || key === 'text')
+            continue;
+        raw[key] = value;
+    }
+    return {
+        ...raw,
+        transcriptTextChars: details.textChars,
+        transcriptTextStoredIn: 'text',
+        transcriptTruncated: details.truncated,
+    };
+}
+function buildOverview(state, features, events, handoffs, assertions, fallback = {}) {
+    const featureSummary = summarizeByStatusAndMilestone(features);
+    const validationSummary = summarizeValidation(assertions);
+    return {
+        missionId: stringValue(state?.missionId) ?? stringValue(fallback.fallbackMissionId),
+        state: stringValue(state?.state) ?? inferStateFromEvents(events) ?? stringValue(fallback.fallbackState),
+        workingDirectory: stringValue(state?.workingDirectory),
+        createdAt: stringValue(state?.createdAt),
+        updatedAt: stringValue(state?.updatedAt),
+        reportOnly: Boolean(fallback.reportOnly),
+        reportCount: fallback.reportCount ?? 0,
+        lastReviewedHandoffCount: numberValue(state?.lastReviewedHandoffCount),
+        featureCount: features.length,
+        handoffCount: handoffs.length,
+        timelineEventCount: events.length,
+        validationAssertionCount: assertions.length,
+        featureStatusCounts: featureSummary.statusCounts,
+        validationStatusCounts: validationSummary.statusCounts,
+    };
+}
+function readMarkdownReports(missionDir, anomalies) {
+    return readdirSync(missionDir)
+        .filter((name) => name.toLowerCase().endsWith('.md'))
+        .sort()
+        .map((name) => {
+        const path = join(missionDir, name);
+        try {
+            const stat = statSync(path);
+            if (!stat.isFile())
+                return null;
+            const raw = readFileSync(path, 'utf8');
+            const truncated = raw.length > REPORT_TEXT_LIMIT;
+            return redactSecrets({
+                path: name,
+                sizeBytes: stat.size,
+                truncated,
+                text: truncated ? `${raw.slice(0, REPORT_TEXT_LIMIT)}\n[truncated]` : raw,
+            });
+        }
+        catch (error) {
+            anomalies.push({
+                severity: 'warning',
+                type: 'unreadable_report',
+                path: name,
+                message: String(error.message ?? error),
+            });
+            return null;
+        }
+    })
+        .filter((item) => Boolean(item));
+}
+function shouldUseReportOnlyMode(state, reports, options) {
+    return !state && reports.length > 0 && Boolean(stringValue(options.factorySessionId));
+}
+function normalizeFeatures(value) {
+    const features = Array.isArray(value?.features) ? value.features : [];
+    return features
+        .filter(isRecord)
+        .map((feature) => {
+        const workerSessionIds = Array.isArray(feature.workerSessionIds)
+            ? feature.workerSessionIds.filter((item) => typeof item === 'string')
+            : [];
+        return redactSecrets({
+            id: stringValue(feature.id),
+            description: stringValue(feature.description),
+            skillName: stringValue(feature.skillName),
+            milestone: stringValue(feature.milestone),
+            status: stringValue(feature.status) ?? 'unknown',
+            workerSessionIds,
+            currentWorkerSessionId: stringValue(feature.currentWorkerSessionId),
+            completedWorkerSessionId: stringValue(feature.completedWorkerSessionId),
+            preconditions: stringArray(feature.preconditions),
+            expectedBehavior: stringArray(feature.expectedBehavior),
+            verificationSteps: stringArray(feature.verificationSteps),
+            raw: feature,
+        });
+    });
+}
+function readJsonLines(filePath, anomalies) {
+    if (!existsSync(filePath)) {
+        anomalies.push({ severity: 'warning', type: 'missing_artifact', path: basename(filePath) });
+        return [];
+    }
+    const lines = readFileSync(filePath, 'utf8').split(/\r?\n/);
+    const events = [];
+    lines.forEach((line, index) => {
+        if (!line.trim())
+            return;
+        try {
+            const parsed = JSON.parse(line);
+            if (isRecord(parsed)) {
+                events.push(redactSecrets({
+                    ...parsed,
+                    timestampMs: parseTimestamp(stringValue(parsed.timestamp)),
+                    lineNumber: index + 1,
+                }));
+            }
+            else {
+                anomalies.push({ severity: 'warning', type: 'invalid_jsonl_record', path: basename(filePath), line: index + 1 });
+            }
+        }
+        catch (error) {
+            anomalies.push({
+                severity: 'warning',
+                type: 'invalid_jsonl',
+                path: basename(filePath),
+                line: index + 1,
+                message: String(error.message ?? error),
+            });
+        }
+    });
+    return events.sort((left, right) => {
+        const leftTime = numberValue(left.timestampMs) ?? 0;
+        const rightTime = numberValue(right.timestampMs) ?? 0;
+        return leftTime - rightTime;
+    });
+}
+function readHandoffs(handoffsDir, anomalies) {
+    if (!existsSync(handoffsDir)) {
+        anomalies.push({ severity: 'warning', type: 'missing_artifact', path: 'handoffs' });
+        return [];
+    }
+    return readdirSync(handoffsDir)
+        .filter((name) => name.endsWith('.json'))
+        .sort()
+        .map((name) => {
+        const path = join(handoffsDir, name);
+        const parsed = readJsonObject(path, anomalies, false);
+        if (!parsed)
+            return null;
+        const handoff = isRecord(parsed.handoff) ? parsed.handoff : {};
+        return redactSecrets({
+            fileName: name,
+            timestamp: stringValue(parsed.timestamp),
+            timestampMs: parseTimestamp(stringValue(parsed.timestamp)),
+            workerSessionId: stringValue(parsed.workerSessionId),
+            featureId: stringValue(parsed.featureId),
+            milestone: stringValue(parsed.milestone),
+            commitId: stringValue(parsed.commitId),
+            repoPath: stringValue(parsed.repoPath),
+            successState: stringValue(parsed.successState),
+            returnToOrchestrator: Boolean(parsed.returnToOrchestrator),
+            salientSummary: stringValue(handoff.salientSummary),
+            verification: isRecord(handoff.verification) ? handoff.verification : null,
+            discoveredIssues: Array.isArray(handoff.discoveredIssues) ? handoff.discoveredIssues : [],
+            raw: parsed,
+        });
+    })
+        .filter((item) => Boolean(item));
+}
+function normalizeValidationAssertions(value) {
+    const assertions = isRecord(value?.assertions) ? value.assertions : {};
+    return Object.entries(assertions)
+        .filter((entry) => isRecord(entry[1]))
+        .map(([id, assertion]) => redactSecrets({
+        id,
+        status: stringValue(assertion.status) ?? 'unknown',
+        note: stringValue(assertion.note),
+        raw: assertion,
+    }))
+        .sort((left, right) => String(left.id).localeCompare(String(right.id)));
+}
+function summarizeByStatusAndMilestone(items) {
+    return {
+        total: items.length,
+        statusCounts: countBy(items, 'status'),
+        milestoneCounts: countBy(items, 'milestone'),
+    };
+}
+function summarizeTimeline(events) {
+    return {
+        total: events.length,
+        typeCounts: countBy(events, 'type'),
+        firstTimestamp: stringValue(events[0]?.timestamp),
+        lastTimestamp: stringValue(events[events.length - 1]?.timestamp),
+    };
+}
+function summarizeHandoffs(items) {
+    return {
+        total: items.length,
+        successStateCounts: countBy(items, 'successState'),
+        milestoneCounts: countBy(items, 'milestone'),
+        latestTimestamp: stringValue(items[items.length - 1]?.timestamp),
+    };
+}
+function summarizeValidation(assertions) {
+    return {
+        total: assertions.length,
+        statusCounts: countBy(assertions, 'status'),
+    };
+}
+function listArtifactFiles(missionDir, anomalies, options = {}) {
+    const files = [];
+    for (const name of JSON_FILES) {
+        const path = join(missionDir, name);
+        files.push({
+            path: name,
+            exists: existsSync(path),
+            sizeBytes: existsSync(path) ? statSync(path).size : null,
+            kind: 'json',
+        });
+    }
+    const progressPath = join(missionDir, 'progress_log.jsonl');
+    files.push({
+        path: 'progress_log.jsonl',
+        exists: existsSync(progressPath),
+        sizeBytes: existsSync(progressPath) ? statSync(progressPath).size : null,
+        kind: 'jsonl',
+    });
+    const transcriptsPath = join(missionDir, 'worker-transcripts.jsonl');
+    files.push({
+        path: 'worker-transcripts.jsonl',
+        exists: existsSync(transcriptsPath),
+        sizeBytes: existsSync(transcriptsPath) ? statSync(transcriptsPath).size : null,
+        kind: 'jsonl_transcript',
+    });
+    const handoffsDir = join(missionDir, 'handoffs');
+    files.push({
+        path: 'handoffs',
+        exists: existsSync(handoffsDir),
+        count: existsSync(handoffsDir) ? readdirSync(handoffsDir).filter((name) => name.endsWith('.json')).length : 0,
+        kind: 'directory',
+    });
+    for (const name of readdirSync(missionDir).filter((entry) => entry.toLowerCase().endsWith('.md')).sort()) {
+        const reportPath = join(missionDir, name);
+        try {
+            const stat = statSync(reportPath);
+            if (stat.isFile()) {
+                files.push({
+                    path: name,
+                    exists: true,
+                    sizeBytes: stat.size,
+                    kind: 'markdown_report',
+                });
+            }
+        }
+        catch {
+            files.push({
+                path: name,
+                exists: false,
+                sizeBytes: null,
+                kind: 'markdown_report',
+            });
+        }
+    }
+    const missingRequired = ['state.json', 'features.json', 'progress_log.jsonl'].filter((name) => {
+        return !existsSync(join(missionDir, name));
+    });
+    for (const path of missingRequired) {
+        anomalies.push({
+            severity: options.reportOnly ? 'warning' : 'error',
+            type: options.reportOnly ? 'missing_structured_artifact' : 'missing_required_artifact',
+            path,
+        });
+    }
+    return files;
+}
+function readJsonObject(filePath, anomalies, optional) {
+    if (!existsSync(filePath)) {
+        if (!optional) {
+            anomalies.push({
+                severity: 'warning',
+                type: 'missing_artifact',
+                path: basename(filePath),
+            });
+            if (isRequiredArtifact(basename(filePath))) {
+                anomalies.push({
+                    severity: 'error',
+                    type: 'missing_required_artifact',
+                    path: basename(filePath),
+                });
+            }
+        }
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+        if (isRecord(parsed))
+            return parsed;
+        anomalies.push({ severity: 'warning', type: 'invalid_json_object', path: basename(filePath) });
+        return null;
+    }
+    catch (error) {
+        anomalies.push({
+            severity: isRequiredArtifact(basename(filePath)) ? 'error' : 'warning',
+            type: isRequiredArtifact(basename(filePath)) ? 'invalid_required_artifact' : 'invalid_json',
+            path: basename(filePath),
+            message: String(error.message ?? error),
+        });
+        return null;
+    }
+}
+function countBy(items, field) {
+    const counts = {};
+    for (const item of items) {
+        const key = stringValue(item[field]) ?? 'unknown';
+        counts[key] = (counts[key] ?? 0) + 1;
+    }
+    return counts;
+}
+function inferTranscriptRole(record) {
+    const searchable = [
+        stringValue(record.role),
+        stringValue(record.featureId),
+        stringValue(record.skillName),
+        stringValue(record.workerSessionId),
+    ].filter(Boolean).join(' ').toLowerCase();
+    if (searchable.includes('validat'))
+        return 'validator';
+    if (searchable.includes('worker'))
+        return 'worker';
+    if (searchable.includes('orchestrator'))
+        return 'orchestrator';
+    return 'worker';
+}
+function firstMeaningfulLine(value) {
+    const line = value.split(/\r?\n/).map((entry) => entry.trim()).find((entry) => entry && !entry.startsWith('---'));
+    return line ? (line.length > 240 ? `${line.slice(0, 240)}...` : line) : 'Transcript captured';
+}
+function redactSecrets(value) {
+    if (Array.isArray(value))
+        return value.map((item) => redactSecrets(item));
+    if (typeof value === 'string')
+        return redactSecretString(value);
+    if (!isRecord(value))
+        return value;
+    const result = {};
+    for (const [key, child] of Object.entries(value)) {
+        result[key] = SENSITIVE_KEY_RE.test(key) ? '[redacted]' : redactSecrets(child);
+    }
+    return result;
+}
+function redactSecretString(value) {
+    return SECRET_VALUE_PATTERNS.reduce((current, pattern) => current.replace(pattern, '[redacted]'), value);
+}
+function isRequiredArtifact(name) {
+    return name === 'state.json' || name === 'features.json' || name === 'progress_log.jsonl';
+}
+function normalizeArtifactAnomalies(anomalies, missionDir, options = {}) {
+    const byKey = new Map();
+    for (const anomaly of anomalies) {
+        const normalized = enrichArtifactAnomaly(anomaly, missionDir, options);
+        const key = [
+            stringValue(normalized.type) ?? 'unknown',
+            stringValue(normalized.path) ?? '',
+            numberValue(normalized.line) ?? '',
+            stringValue(normalized.severity) ?? '',
+        ].join(':');
+        byKey.set(key, { ...byKey.get(key), ...normalized });
+    }
+    return Array.from(byKey.values()).sort((left, right) => {
+        const leftSeverity = severityRank(stringValue(left.severity));
+        const rightSeverity = severityRank(stringValue(right.severity));
+        if (leftSeverity !== rightSeverity)
+            return leftSeverity - rightSeverity;
+        return String(left.path ?? '').localeCompare(String(right.path ?? ''));
+    });
+}
+function enrichArtifactAnomaly(anomaly, missionDir, options) {
+    let severity = stringValue(anomaly.severity) ?? 'warning';
+    let type = stringValue(anomaly.type) ?? 'unknown_artifact_anomaly';
+    const path = stringValue(anomaly.path);
+    if (path && isRequiredArtifact(path) && (type === 'missing_artifact' || type === 'missing_required_artifact')) {
+        type = options.reportOnly ? 'missing_structured_artifact' : 'missing_required_artifact';
+        severity = options.reportOnly ? 'warning' : 'error';
+    }
+    else if (options.reportOnly && type === 'missing_required_artifact') {
+        severity = 'warning';
+        type = 'missing_structured_artifact';
+    }
+    const preset = anomalyPreset(type, path, options);
+    return {
+        severity,
+        type,
+        category: preset.category,
+        title: preset.title,
+        message: stringValue(anomaly.message) ?? preset.message,
+        guidance: preset.guidance,
+        blocking: severity === 'error',
+        ...(path ? { path, checkedPath: join(missionDir, path) } : {}),
+        ...(numberValue(anomaly.line) != null ? { line: numberValue(anomaly.line) } : {}),
+    };
+}
+function anomalyPreset(type, path, options) {
+    const label = path ?? 'artifact';
+    if (type === 'missing_required_artifact') {
+        return {
+            category: 'missing',
+            title: `Missing required artifact: ${label}`,
+            message: `${label} was not found in the Droid mission artifact directory.`,
+            guidance: 'Import may be incomplete. Re-run the mission or inspect the Droid/Factory artifact directory used for this snapshot.',
+        };
+    }
+    if (type === 'missing_structured_artifact') {
+        return {
+            category: 'missing',
+            title: `Missing structured artifact: ${label}`,
+            message: options.reportOnly
+                ? `${label} was not found, but Markdown report output was imported.`
+                : `${label} was not found in the Droid mission artifact directory.`,
+            guidance: options.reportOnly
+                ? 'Review the imported Markdown report; structured Features, Timeline, Handoffs, or Validation may remain sparse.'
+                : 'Re-run the mission or inspect the Droid/Factory artifact directory.',
+        };
+    }
+    if (type === 'missing_artifact') {
+        return {
+            category: 'missing',
+            title: `Missing optional artifact: ${label}`,
+            message: `${label} was not found in the Droid mission artifact directory.`,
+            guidance: 'Some sections may be empty. This is expected for partial or report-only Droid output.',
+        };
+    }
+    if (type === 'invalid_required_artifact' || type === 'invalid_json_object' || type === 'invalid_json') {
+        return {
+            category: 'parse',
+            title: `Invalid JSON artifact: ${label}`,
+            message: `${label} could not be parsed as a JSON object.`,
+            guidance: 'Open the artifact file and check whether Droid wrote partial or malformed JSON.',
+        };
+    }
+    if (type === 'invalid_jsonl' || type === 'invalid_jsonl_record') {
+        return {
+            category: 'parse',
+            title: `Invalid JSONL record: ${label}`,
+            message: `${label} contains at least one line that could not be parsed as a JSON object.`,
+            guidance: 'The importer skipped malformed lines and kept valid timeline events.',
+        };
+    }
+    if (type === 'unreadable_report') {
+        return {
+            category: 'report',
+            title: `Unreadable report: ${label}`,
+            message: `${label} could not be read as Markdown report text.`,
+            guidance: 'Check file permissions and whether the report still exists in the artifact directory.',
+        };
+    }
+    return {
+        category: 'unknown',
+        title: `Artifact anomaly: ${type}`,
+        message: `${type} was reported while importing Droid artifacts.`,
+        guidance: 'Inspect raw anomaly details and the artifact directory.',
+    };
+}
+function summarizeAnomalies(anomalies) {
+    return {
+        total: anomalies.length,
+        errorCount: anomalies.filter((item) => stringValue(item.severity) === 'error').length,
+        warningCount: anomalies.filter((item) => stringValue(item.severity) === 'warning').length,
+        blockingCount: anomalies.filter((item) => item.blocking === true).length,
+        categoryCounts: countBy(anomalies, 'category'),
+    };
+}
+function severityRank(value) {
+    if (value === 'error')
+        return 0;
+    if (value === 'warning')
+        return 1;
+    return 2;
+}
+function inferStateFromEvents(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const type = stringValue(events[index]?.type);
+        if (type === 'mission_paused')
+            return 'paused';
+        if (type === 'mission_completed')
+            return 'completed';
+        if (type === 'mission_run_started' || type === 'mission_resumed')
+            return 'running';
+    }
+    return null;
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+function parseTimestamp(value) {
+    if (!value)
+        return null;
+    const time = Date.parse(value);
+    return Number.isFinite(time) ? time : null;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.trim() ? value : null;
+}
+function numberValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}