hadara 0.1.0-rc.0

package/dist/services/policy-service.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPolicyCheckReport = createPolicyCheckReport;
+exports.createPolicyEvaluateReport = createPolicyEvaluateReport;
+const preflight_1 = require("../policy/preflight");
+const policy_1 = require("../policy/policy");
+function createPolicyCheckReport(command, mode = 'assisted') {
+    const normalizedMode = (0, policy_1.parsePermissionMode)(mode);
+    const shell = (0, policy_1.tokenizeShellCommand)(command);
+    const decision = (0, policy_1.classifyShellCommand)(command, normalizedMode);
+    return {
+        schemaVersion: 'hadara.policy.check-shell.v1',
+        command: 'policy.check-shell',
+        ok: decision.action !== 'deny',
+        input: {
+            mode: normalizedMode,
+            command
+        },
+        shell,
+        decision
+    };
+}
+function createPolicyEvaluateReport(command, mode = 'assisted') {
+    return (0, preflight_1.createShellExecutionPreflight)(command, (0, policy_1.parsePermissionMode)(mode));
+}

package/dist/services/project-read-model.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readProjectFile = readProjectFile;
+exports.readProjectSources = readProjectSources;
+exports.createHandoffReadReport = createHandoffReadReport;
+exports.createProjectStateReadReport = createProjectStateReadReport;
+exports.tailLines = tailLines;
+exports.extractSection = extractSection;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function readProjectFile(projectRoot, relativePath) {
+    const filePath = node_path_1.default.join(projectRoot, relativePath);
+    const exists = node_fs_1.default.existsSync(filePath);
+    return {
+        path: relativePath,
+        exists,
+        content: exists ? node_fs_1.default.readFileSync(filePath, 'utf8') : ''
+    };
+}
+function readProjectSources(projectRoot) {
+    return {
+        projectState: readProjectFile(projectRoot, 'docs/PROJECT_STATE.md'),
+        handoff: readProjectFile(projectRoot, 'docs/AGENT_HANDOFF.md'),
+        taskBoard: readProjectFile(projectRoot, 'docs/TASK_BOARD.md'),
+        developmentSlices: readProjectFile(projectRoot, 'docs/DEVELOPMENT_SLICES.md'),
+        validationHistory: readProjectFile(projectRoot, 'docs/VALIDATION_HISTORY.md')
+    };
+}
+function createHandoffReadReport(projectRoot, options) {
+    const sources = readProjectSources(projectRoot);
+    return {
+        schemaVersion: 'hadara.handoff.read.v1',
+        command: 'handoff.read',
+        ok: true,
+        handoff: {
+            current: sources.handoff.content,
+            history: options.includeHistory ? tailLines(readProjectFile(projectRoot, 'docs/HANDOFF_HISTORY.md').content, options.historyLimit) : null,
+            validationHistory: options.includeHistory ? tailLines(sources.validationHistory.content, options.historyLimit) : null
+        },
+        issues: []
+    };
+}
+function createProjectStateReadReport(projectRoot, options) {
+    const sources = readProjectSources(projectRoot);
+    if (options.summaryOnly) {
+        return {
+            schemaVersion: 'hadara.project.state.read.v1',
+            command: 'project.state.read',
+            ok: true,
+            summary: {
+                projectState: extractSection(sources.projectState.content, '## Current Status'),
+                taskBoardTail: tailLines(sources.taskBoard.content, 20),
+                developmentSlicesTail: tailLines(sources.developmentSlices.content, 12)
+            },
+            issues: []
+        };
+    }
+    if (!options.includeDocuments) {
+        return {
+            schemaVersion: 'hadara.project.state.read.v1',
+            command: 'project.state.read',
+            ok: true,
+            documents: [
+                { path: sources.projectState.path, included: false },
+                { path: sources.taskBoard.path, included: false },
+                { path: sources.developmentSlices.path, included: false }
+            ],
+            issues: []
+        };
+    }
+    return {
+        schemaVersion: 'hadara.project.state.read.v1',
+        command: 'project.state.read',
+        ok: true,
+        projectState: sources.projectState.content,
+        taskBoard: sources.taskBoard.content,
+        developmentSlices: sources.developmentSlices.content,
+        issues: []
+    };
+}
+function tailLines(content, limit) {
+    return content
+        .split(/\r?\n/)
+        .filter((line) => line.trim().length > 0)
+        .slice(-limit)
+        .join('\n');
+}
+function extractSection(content, heading) {
+    const match = new RegExp(`^${escapeRegExp(heading)}\\s*$`, 'm').exec(content);
+    if (!match || match.index === undefined)
+        return '';
+    const afterHeading = content.slice(match.index + match[0].length);
+    const nextHeading = afterHeading.search(/\n##\s+/);
+    return (nextHeading >= 0 ? afterHeading.slice(0, nextHeading) : afterHeading).trim();
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/services/release-artifact-evidence.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachReleaseArtifactEvidence = attachReleaseArtifactEvidence;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const evidence_1 = require("../evidence/evidence");
+const fs_1 = require("../core/fs");
+const redaction_1 = require("../core/redaction");
+const release_dry_run_1 = require("./release-dry-run");
+function attachReleaseArtifactEvidence(input) {
+    const taskDir = findTaskDir(input.projectRoot, input.taskId);
+    if (!taskDir)
+        throw new Error(`Task capsule not found: ${input.taskId}`);
+    const time = new Date().toISOString();
+    const reportArtifact = {
+        ...input.report,
+        evidence: {
+            time,
+            taskId: input.taskId,
+            gitCommit: (0, release_dry_run_1.readCurrentGitCommit)(input.projectRoot)
+        }
+    };
+    const content = JSON.stringify(reportArtifact, null, 2);
+    const policy = (0, evidence_1.createPublicEvidenceArtifactPolicyReport)(content);
+    if (policy.blocking) {
+        throw new evidence_1.EvidenceArtifactPolicyError('PUBLIC_ARTIFACT_SECRET_DETECTED', 'Public release artifact evidence contains secret-like content; reduce the report before attaching.', policy.redaction);
+    }
+    const artifactDir = node_path_1.default.join(taskDir, 'artifacts', 'release-artifact');
+    (0, fs_1.ensureDir)(artifactDir);
+    const targetPath = node_path_1.default.join(artifactDir, `${safeFilePart(time)}-report.json`);
+    node_fs_1.default.writeFileSync(targetPath, content, 'utf8');
+    const evidencePath = toPortablePath(node_path_1.default.relative(taskDir, targetPath));
+    const evidence = {
+        schemaVersion: 'hadara.evidence.v1',
+        time,
+        taskId: input.taskId,
+        kind: 'command-log',
+        summary: (0, redaction_1.redactSecrets)(input.summary.replace(/\|/g, '/')),
+        result: input.report.ok ? 'passed' : 'failed',
+        visibility: 'public',
+        evidencePath
+    };
+    appendEvidenceMarkdown(taskDir, evidence);
+    node_fs_1.default.appendFileSync(node_path_1.default.join(taskDir, 'evidence.jsonl'), `${JSON.stringify(evidence)}\n`, 'utf8');
+    return {
+        evidence,
+        artifact: {
+            kind: 'report',
+            visibility: 'public',
+            evidencePath: toPortablePath(node_path_1.default.join('tasks', node_path_1.default.basename(taskDir), evidencePath)),
+            rawContentIncluded: false
+        }
+    };
+}
+function appendEvidenceMarkdown(taskDir, evidence) {
+    const markdownPath = node_path_1.default.join(taskDir, 'EVIDENCE.md');
+    if (!node_fs_1.default.existsSync(markdownPath)) {
+        node_fs_1.default.writeFileSync(markdownPath, '# Evidence\n\n| Time | Kind | Summary | Result |\n|---|---|---|---|\n', 'utf8');
+    }
+    node_fs_1.default.appendFileSync(markdownPath, `| ${evidence.time} | ${evidence.kind} | ${evidence.summary} (${evidence.evidencePath}) | ${evidence.result} |\n`, 'utf8');
+}
+function findTaskDir(projectRoot, taskId) {
+    const tasksDir = node_path_1.default.join(projectRoot, 'tasks');
+    if (!node_fs_1.default.existsSync(tasksDir))
+        return null;
+    const entry = node_fs_1.default.readdirSync(tasksDir).find((name) => name.startsWith(`${taskId}-`));
+    return entry ? node_path_1.default.join(tasksDir, entry) : null;
+}
+function safeFilePart(value) {
+    return value.replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'artifact';
+}
+function toPortablePath(value) {
+    return value.split(node_path_1.default.sep).join('/');
+}

package/dist/services/release-artifact.js

@@ -0,0 +1,351 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReleaseArtifactReport = createReleaseArtifactReport;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const fs_1 = require("../core/fs");
+const schema_1 = require("../core/schema");
+const requiredFiles = ['package.json', 'README.md', 'LICENSE', 'dist/cli/main.js'];
+const allowedRoots = ['dist/', 'README.md', 'LICENSE', 'package.json'];
+function createReleaseArtifactReport(options) {
+    const issues = [];
+    validateTimeout(options.timeoutSeconds, issues);
+    if (options.execute !== true) {
+        issues.push({
+            severity: 'error',
+            code: 'RELEASE_ARTIFACT_EXECUTION_REQUIRED',
+            message: 'Release artifact building requires explicit --execute because it runs npm pack and writes artifacts.'
+        });
+    }
+    const packageMetadata = readPackageMetadata(options.paths.projectRoot, issues);
+    const output = prepareOutput(options.paths.projectRoot, options.output, options.keepTemp === true, issues);
+    const staging = prepareStaging(options.paths.projectRoot, issues);
+    const runner = options.runner ?? runCommand;
+    const timeoutMs = (options.timeoutSeconds ?? 120) * 1000;
+    const execution = {
+        stagingCreated: false,
+        npmPackExecuted: false,
+        checksumGenerated: false,
+        manifestGenerated: false,
+        packageContentsVerified: false,
+        publishExecuted: false,
+        githubReleaseCreated: false,
+        dockerImageBuilt: false
+    };
+    const artifacts = [];
+    const packageContents = {
+        verified: false,
+        fileCount: 0,
+        allowedRoots,
+        requiredFiles,
+        forbiddenMatches: []
+    };
+    try {
+        if (!issues.some((issue) => issue.severity === 'error')) {
+            copyWhitelistedPackage(options.paths.projectRoot, staging.path, packageMetadata, issues);
+            execution.stagingCreated = !issues.some((issue) => issue.stepId === 'stage-package');
+            if (execution.stagingCreated) {
+                execution.npmPackExecuted = true;
+                const pack = runner(npmCommand(), ['pack', '--json', '--pack-destination', output.path], {
+                    cwd: staging.path,
+                    timeoutMs
+                });
+                const parsed = parsePackResult(pack.stdout);
+                if (pack.status !== 0 || !parsed) {
+                    issues.push({
+                        severity: 'error',
+                        code: pack.timedOut ? 'RELEASE_ARTIFACT_NPM_PACK_TIMEOUT' : 'RELEASE_ARTIFACT_NPM_PACK_FAILED',
+                        message: pack.timedOut ? 'npm pack timed out while building release artifacts.' : 'npm pack failed or did not return a reduced package result.',
+                        stepId: 'npm-pack'
+                    });
+                }
+                else {
+                    const verify = verifyPackageContents(parsed.files.map((file) => file.path));
+                    packageContents.verified = verify.ok;
+                    packageContents.fileCount = parsed.files.length;
+                    packageContents.forbiddenMatches = verify.forbidden;
+                    execution.packageContentsVerified = verify.ok;
+                    for (const missing of verify.missingRequired) {
+                        issues.push({
+                            severity: 'error',
+                            code: 'RELEASE_ARTIFACT_REQUIRED_FILE_MISSING',
+                            message: `Release artifact package is missing required file ${missing}.`,
+                            stepId: 'verify-contents'
+                        });
+                    }
+                    for (const forbidden of verify.forbidden) {
+                        issues.push({
+                            severity: 'error',
+                            code: 'RELEASE_ARTIFACT_FORBIDDEN_FILE_INCLUDED',
+                            message: `Release artifact package includes file outside the whitelist: ${forbidden}.`,
+                            stepId: 'verify-contents'
+                        });
+                    }
+                    const tarballPath = node_path_1.default.join(output.path, parsed.filename);
+                    const tarballHash = hashFile(tarballPath);
+                    artifacts.push(createArtifact('tarball', output, parsed.filename, tarballPath, tarballHash));
+                    const checksumFileName = `${parsed.filename}.sha256`;
+                    node_fs_1.default.writeFileSync(node_path_1.default.join(output.path, checksumFileName), `${tarballHash}  ${parsed.filename}\n`, 'utf8');
+                    execution.checksumGenerated = true;
+                    artifacts.push(createArtifact('checksum', output, checksumFileName, node_path_1.default.join(output.path, checksumFileName), hashFile(node_path_1.default.join(output.path, checksumFileName))));
+                    const manifestFileName = `${parsed.filename}.manifest.json`;
+                    const manifest = createManifest(packageMetadata, parsed, tarballHash);
+                    node_fs_1.default.writeFileSync(node_path_1.default.join(output.path, manifestFileName), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+                    execution.manifestGenerated = true;
+                    artifacts.push(createArtifact('manifest', output, manifestFileName, node_path_1.default.join(output.path, manifestFileName), hashFile(node_path_1.default.join(output.path, manifestFileName))));
+                }
+            }
+        }
+    }
+    finally {
+        cleanupDirectory(staging.path, true);
+        if (output.cleanupAllowed)
+            cleanupDirectory(output.path, false);
+    }
+    const report = {
+        schemaVersion: 'hadara.releaseArtifact.v1',
+        command: 'release.artifact',
+        ok: issues.every((issue) => issue.severity !== 'error'),
+        mode: 'execute',
+        execution,
+        output: {
+            kind: output.kind,
+            displayPath: output.displayPath,
+            pathRedacted: true,
+            ...(output.relativePath ? { relativePath: output.relativePath } : {}),
+            retention: output.retention
+        },
+        package: {
+            name: packageMetadata.name,
+            version: packageMetadata.version,
+            private: packageMetadata.private,
+            filesWhitelistApplied: true
+        },
+        artifacts,
+        packageContents,
+        privacy: {
+            rawLogsIncluded: false,
+            packageContentsIncluded: false,
+            privatePathsIncluded: false,
+            environmentSecretsIncluded: false,
+            privateStorePathsIncluded: false
+        },
+        issues
+    };
+    (0, schema_1.assertSchema)('hadara.releaseArtifact.v1', report);
+    return report;
+}
+function readPackageMetadata(projectRoot, issues) {
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(projectRoot, 'package.json'), 'utf8'));
+        const bin = isRecord(parsed.bin) ? parsed.bin : {};
+        if (parsed.name !== 'hadara') {
+            issues.push({ severity: 'error', code: 'RELEASE_ARTIFACT_PACKAGE_NAME_INVALID', message: 'Release artifact package name must be hadara.' });
+        }
+        if (bin.hadara !== './dist/cli/main.js') {
+            issues.push({ severity: 'error', code: 'RELEASE_ARTIFACT_BIN_MISSING', message: 'Release artifact package must expose bin.hadara at ./dist/cli/main.js.' });
+        }
+        return {
+            name: typeof parsed.name === 'string' ? parsed.name : 'unknown',
+            version: typeof parsed.version === 'string' ? parsed.version : '0.0.0',
+            private: parsed.private === true,
+            ...(typeof parsed.license === 'string' ? { license: parsed.license } : {})
+        };
+    }
+    catch {
+        issues.push({
+            severity: 'error',
+            code: 'RELEASE_ARTIFACT_PACKAGE_JSON_MISSING',
+            message: 'Release artifact builder requires readable package.json metadata.'
+        });
+        return { name: 'unknown', version: '0.0.0', private: true };
+    }
+}
+function prepareOutput(projectRoot, output, keepTemp, issues) {
+    const outputPath = output ? node_path_1.default.resolve(projectRoot, output) : node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'hadara-release-artifact-'));
+    try {
+        (0, fs_1.ensureDir)(outputPath);
+    }
+    catch {
+        issues.push({
+            severity: 'error',
+            code: 'RELEASE_ARTIFACT_OUTPUT_CREATE_FAILED',
+            message: 'Release artifact output directory could not be created.'
+        });
+    }
+    const relativePath = safeRelativePath(output);
+    return {
+        kind: output ? 'explicit' : 'disposable',
+        path: outputPath,
+        displayPath: relativePath ? `./${relativePath}` : '<redacted-release-artifact-output>',
+        ...(relativePath ? { relativePath } : {}),
+        retention: output ? 'explicit-output' : keepTemp ? 'kept-temporary' : 'deleted',
+        cleanupAllowed: !output && !keepTemp
+    };
+}
+function prepareStaging(projectRoot, issues) {
+    const staging = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'hadara-release-artifact-stage-'));
+    for (const required of ['dist/cli/main.js', 'README.md', 'LICENSE']) {
+        if (!node_fs_1.default.existsSync(node_path_1.default.join(projectRoot, required))) {
+            issues.push({
+                severity: 'error',
+                code: 'RELEASE_ARTIFACT_REQUIRED_SOURCE_MISSING',
+                message: `Release artifact source is missing required file ${required}.`,
+                stepId: 'stage-package'
+            });
+        }
+    }
+    return { path: staging };
+}
+function copyWhitelistedPackage(projectRoot, staging, metadata, issues) {
+    try {
+        node_fs_1.default.cpSync(node_path_1.default.join(projectRoot, 'dist'), node_path_1.default.join(staging, 'dist'), { recursive: true });
+        node_fs_1.default.copyFileSync(node_path_1.default.join(projectRoot, 'README.md'), node_path_1.default.join(staging, 'README.md'));
+        node_fs_1.default.copyFileSync(node_path_1.default.join(projectRoot, 'LICENSE'), node_path_1.default.join(staging, 'LICENSE'));
+        node_fs_1.default.writeFileSync(node_path_1.default.join(staging, 'package.json'), `${JSON.stringify({
+            name: metadata.name,
+            version: metadata.version,
+            private: metadata.private,
+            ...(metadata.license ? { license: metadata.license } : {}),
+            description: 'HADARA: portable agentic development workbench',
+            bin: { hadara: './dist/cli/main.js' },
+            files: ['dist/', 'README.md', 'LICENSE', 'package.json']
+        }, null, 2)}\n`, 'utf8');
+    }
+    catch {
+        issues.push({
+            severity: 'error',
+            code: 'RELEASE_ARTIFACT_STAGE_FAILED',
+            message: 'Release artifact staging package could not be created.',
+            stepId: 'stage-package'
+        });
+    }
+}
+function parsePackResult(stdout) {
+    try {
+        const parsed = JSON.parse(stdout);
+        if (!Array.isArray(parsed))
+            return undefined;
+        const first = parsed[0];
+        if (!first || typeof first.filename !== 'string' || first.filename.includes('/') || first.filename.includes('\\'))
+            return undefined;
+        const files = Array.isArray(first.files)
+            ? first.files
+                .map((file) => {
+                if (!isRecord(file) || typeof file.path !== 'string')
+                    return undefined;
+                return {
+                    path: file.path,
+                    ...(typeof file.size === 'number' ? { size: file.size } : {})
+                };
+            })
+                .filter((file) => file !== undefined)
+            : [];
+        return { filename: first.filename, files };
+    }
+    catch {
+        return undefined;
+    }
+}
+function verifyPackageContents(files) {
+    const forbidden = files.filter((file) => !allowedRoots.some((root) => file === root || (root.endsWith('/') && file.startsWith(root))));
+    const missingRequired = requiredFiles.filter((required) => !files.includes(required));
+    return {
+        ok: forbidden.length === 0 && missingRequired.length === 0,
+        forbidden,
+        missingRequired
+    };
+}
+function createManifest(metadata, pack, tarballHash) {
+    return {
+        schemaVersion: 'hadara.releaseArtifact.manifest.v1',
+        package: metadata,
+        tarball: {
+            fileName: pack.filename,
+            hash: `sha256:${tarballHash}`
+        },
+        files: pack.files.map((file) => ({
+            path: file.path,
+            ...(file.size === undefined ? {} : { byteLength: file.size })
+        })),
+        releaseMutationExecuted: false,
+        publishExecuted: false,
+        githubReleaseCreated: false
+    };
+}
+function createArtifact(kind, output, fileName, filePath, hash) {
+    return {
+        kind,
+        visibility: output.kind === 'explicit' ? 'local' : 'temporary',
+        fileName,
+        ...(output.relativePath ? { relativePath: `${output.relativePath}/${fileName}` } : {}),
+        pathRedacted: true,
+        byteLength: safeFileSize(filePath),
+        hash: `sha256:${hash}`,
+        rawContentIncluded: false
+    };
+}
+function hashFile(filePath) {
+    const hash = node_crypto_1.default.createHash('sha256');
+    hash.update(node_fs_1.default.readFileSync(filePath));
+    return hash.digest('hex');
+}
+function safeFileSize(filePath) {
+    try {
+        return node_fs_1.default.statSync(filePath).size;
+    }
+    catch {
+        return 0;
+    }
+}
+function cleanupDirectory(directory, cleanup) {
+    if (cleanup)
+        node_fs_1.default.rmSync(directory, { recursive: true, force: true });
+}
+function runCommand(command, args, options) {
+    const started = Date.now();
+    const result = (0, node_child_process_1.spawnSync)(command, args, {
+        cwd: options.cwd,
+        encoding: 'utf8',
+        timeout: options.timeoutMs,
+        maxBuffer: 1024 * 1024 * 4
+    });
+    return {
+        status: typeof result.status === 'number' ? result.status : null,
+        signal: result.signal,
+        stdout: result.stdout ?? '',
+        stderr: result.stderr ?? '',
+        elapsedMs: Date.now() - started,
+        timedOut: result.error?.name === 'TimeoutError' || result.signal === 'SIGTERM'
+    };
+}
+function validateTimeout(timeoutSeconds, issues) {
+    if (timeoutSeconds !== undefined && (!Number.isSafeInteger(timeoutSeconds) || timeoutSeconds < 1)) {
+        issues.push({
+            severity: 'error',
+            code: 'RELEASE_ARTIFACT_TIMEOUT_INVALID',
+            message: 'Release artifact timeout must be a positive integer number of seconds.'
+        });
+    }
+}
+function npmCommand() {
+    return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+function safeRelativePath(value) {
+    if (!value || node_path_1.default.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith('~') || value.startsWith('<') || value.includes('%')) {
+        return undefined;
+    }
+    const normalized = value.split(/[\\/]+/).filter(Boolean).join('/');
+    if (!normalized || normalized === '.' || normalized.startsWith('..'))
+        return undefined;
+    return normalized;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}