@elench/testkit 0.1.118 → 0.1.120

package/lib/app/doctor.mjs

@@ -1,16 +1,14 @@
-import fs from "fs";
 import path from "path";
-import ts from "typescript";
 import { discoverTests } from "../discovery/index.mjs";
 import { loadConfigContext } from "../config/index.mjs";
 import { runTestkitTypecheck } from "./typecheck.mjs";
-import { findConfigFile } from "../config/config-loader.mjs";
+import { runLint } from "../lint/index.mjs";
 
 export async function runDoctor(options = {}) {
   const checks = [];
   const productDir = options.dir ? path.resolve(process.cwd(), options.dir) : process.cwd();
 
-  await loadConfigContext({ dir: productDir });
+  const context = await loadConfigContext({ dir: productDir });
   checks.push({
     code: "config-load",
     level: "pass",
@@ -29,26 +27,18 @@ export async function runDoctor(options = {}) {
     details: discoveryErrors,
   });
 
-  const playwrightViolations = findPlaywrightRuntimeImportViolations(productDir);
-  checks.push({
-    code: "ui-runtime-imports",
-    level: playwrightViolations.length === 0 ? "pass" : "fail",
-    message:
-      playwrightViolations.length === 0
-        ? "No runtime @playwright/test imports found in testkit UI suites"
-        : `Found ${playwrightViolations.length} UI runtime import violation(s); import from @elench/testkit/ui instead`,
-    details: playwrightViolations,
+  const lint = await runLint({
+    dir: productDir,
+    ...(context.config?.lint || {}),
   });
-
-  const configImportViolations = findConfigImportViolations(productDir);
   checks.push({
-    code: "config-import-hygiene",
-    level: configImportViolations.length === 0 ? "pass" : "fail",
+    code: "lint",
+    level: lint.ok ? "pass" : "fail",
     message:
-      configImportViolations.length === 0
-        ? "Repo config does not import __testkit__ helper modules"
-        : `Found ${configImportViolations.length} repo config import violation(s)`,
-    details: configImportViolations,
+      lint.ok
+        ? `No Testkit lint violations across ${lint.summary.testkitFiles} suite file(s)`
+        : `Found ${lint.summary.violations} Testkit lint violation(s)`,
+    details: lint.violations,
   });
 
   const hasBrowserOrNextWork = discovery.files.some((entry) => entry.type === "ui");
@@ -88,95 +78,3 @@ export async function runDoctor(options = {}) {
     checks,
   };
 }
-
-function findPlaywrightRuntimeImportViolations(productDir) {
-  const violations = [];
-  for (const absolutePath of collectFiles(productDir)) {
-    const sourceText = fs.readFileSync(absolutePath, "utf8");
-    const sourceFile = ts.createSourceFile(absolutePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-
-    for (const statement of sourceFile.statements) {
-      if (!ts.isImportDeclaration(statement)) continue;
-      if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
-      if (statement.moduleSpecifier.text !== "@playwright/test") continue;
-      const clause = statement.importClause;
-      if (clause?.isTypeOnly) continue;
-      if (!clause) {
-        violations.push(relativeViolation(productDir, absolutePath, sourceFile, statement));
-        continue;
-      }
-      if (clause.name) {
-        violations.push(relativeViolation(productDir, absolutePath, sourceFile, statement));
-        continue;
-      }
-      if (!clause.namedBindings) {
-        violations.push(relativeViolation(productDir, absolutePath, sourceFile, statement));
-        continue;
-      }
-      if (ts.isNamespaceImport(clause.namedBindings)) {
-        violations.push(relativeViolation(productDir, absolutePath, sourceFile, statement));
-        continue;
-      }
-      if (clause.namedBindings.elements.some((entry) => !entry.isTypeOnly)) {
-        violations.push(relativeViolation(productDir, absolutePath, sourceFile, statement));
-      }
-    }
-  }
-  return violations;
-}
-
-function findConfigImportViolations(productDir) {
-  const configFile = findConfigFile(productDir);
-  if (!configFile || !fs.existsSync(configFile)) return [];
-
-  const sourceText = fs.readFileSync(configFile, "utf8");
-  const sourceFile = ts.createSourceFile(configFile, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-  const violations = [];
-
-  for (const statement of sourceFile.statements) {
-    if (!ts.isImportDeclaration(statement)) continue;
-    if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
-    const specifier = statement.moduleSpecifier.text;
-    if (!isRepoLocalConfigImportViolation(specifier)) continue;
-    const position = sourceFile.getLineAndCharacterOfPosition(statement.getStart(sourceFile));
-    violations.push({
-      file: path.relative(productDir, configFile).split(path.sep).join("/"),
-      line: position.line + 1,
-      specifier,
-      snippet: statement.getText(sourceFile),
-    });
-  }
-
-  return violations;
-}
-
-function collectFiles(rootDir, out = []) {
-  if (!fs.existsSync(rootDir)) return out;
-  for (const entry of fs.readdirSync(rootDir, { withFileTypes: true })) {
-    const absolutePath = path.join(rootDir, entry.name);
-    if (entry.isDirectory()) {
-      if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".testkit") continue;
-      collectFiles(absolutePath, out);
-      continue;
-    }
-    if (entry.isFile() && (entry.name.endsWith(".ui.testkit.ts") || entry.name.endsWith(".ui.testkit.ts"))) {
-      out.push(absolutePath);
-    }
-  }
-  return out.sort((left, right) => left.localeCompare(right));
-}
-
-function isRepoLocalConfigImportViolation(specifier) {
-  if (typeof specifier !== "string") return false;
-  if (!specifier.startsWith(".") && !specifier.startsWith("/")) return false;
-  return specifier.includes("__testkit__");
-}
-
-function relativeViolation(productDir, absolutePath, sourceFile, statement) {
-  const position = sourceFile.getLineAndCharacterOfPosition(statement.getStart(sourceFile));
-  return {
-    file: path.relative(productDir, absolutePath).split(path.sep).join("/"),
-    line: position.line + 1,
-    snippet: statement.getText(sourceFile),
-  };
-}

package/lib/cli/assistant/command-observer.mjs

@@ -3,7 +3,7 @@ import path from "path";
 import { isAssistantRunCommand } from "./command-classifier.mjs";
 
 const POLL_INTERVAL_MS = 150;
-const OBSERVED_KINDS = new Set(["run", "discover", "status", "doctor", "typecheck"]);
+const OBSERVED_KINDS = new Set(["run", "discover", "status", "doctor", "lint", "typecheck"]);
 
 export function createAssistantCommandObserver({
   productDir,

package/lib/cli/assistant/state.mjs

@@ -10,6 +10,7 @@ import { createRunState } from "../state/run/state.mjs";
 import { buildContextSelection } from "../../results/context.mjs";
 import { renderDiscoverResult } from "../renderers/discover/text.mjs";
 import { renderDoctorResult } from "../renderers/doctor/text.mjs";
+import { renderLintResult } from "../renderers/lint/text.mjs";
 import { renderStatusResult } from "../renderers/status/text.mjs";
 import { renderTypecheckResult } from "../renderers/typecheck/text.mjs";
 import { isProviderInstalled } from "./providers/index.mjs";
@@ -1092,6 +1093,7 @@ function renderObservedCommandResult(command) {
     return normalizeRenderedLines((result.results || []).flatMap((entry) => renderStatusResult(entry)));
   }
   if (command.kind === "doctor") return normalizeRenderedLines(renderDoctorResult(result));
+  if (command.kind === "lint") return normalizeRenderedLines(renderLintResult(result));
   if (command.kind === "typecheck") return normalizeRenderedLines(renderTypecheckResult(result));
   return [];
 }

package/lib/cli/commands/lint.mjs

@@ -0,0 +1,41 @@
+import { Command, Flags } from "@oclif/core";
+import { executeLintOperation } from "../operations/lint/operation.mjs";
+import { renderLintResult } from "../renderers/lint/text.mjs";
+import { withAssistantCommandResult } from "../assistant/command-results.mjs";
+
+export default class LintCommand extends Command {
+  static summary = "Run built-in Testkit repository hygiene checks";
+
+  static enableJsonFlag = true;
+
+  static flags = {
+    dir: Flags.string({
+      description: "Product directory",
+    }),
+    "testkit-boundary": Flags.boolean({
+      description: "Fail when tracked Testkit plumbing exists outside testkit.config.* or __testkit__/ paths",
+      default: false,
+    }),
+  };
+
+  async run() {
+    return withAssistantCommandResult("lint", async () => {
+      const { flags } = await this.parse(LintCommand);
+      const result = await executeLintOperation(flags);
+
+      if (!this.jsonEnabled()) {
+        for (const line of renderLintResult(result)) {
+          this.log(line);
+        }
+      }
+
+      if (!result.ok) {
+        const error = new Error("testkit lint failed");
+        error.result = result;
+        throw error;
+      }
+
+      return result;
+    });
+  }
+}

package/lib/cli/entrypoint.mjs

@@ -13,6 +13,7 @@ export function normalizeCliArgs(argv) {
     "discover",
     "typecheck",
     "doctor",
+    "lint",
     "browser",
     "db",
   ]);

package/lib/cli/operations/lint/operation.mjs

@@ -0,0 +1,20 @@
+import { runLint } from "../../../lint/index.mjs";
+import { loadTestkitConfig } from "../../../config/config-loader.mjs";
+import { resolveProductDir } from "../../../config/paths.mjs";
+
+export async function executeLintOperation(flags = {}) {
+  const productDir = resolveProductDir(process.cwd(), flags.dir);
+  const { config } = await loadTestkitConfig(productDir);
+  const cliLint = flags["testkit-boundary"]
+    ? { rules: { testkitBoundary: true } }
+    : {};
+  return runLint({
+    dir: productDir,
+    ...(config.lint || {}),
+    ...cliLint,
+    rules: {
+      ...(config.lint?.rules || {}),
+      ...(cliLint.rules || {}),
+    },
+  });
+}

package/lib/cli/renderers/doctor/text.mjs

@@ -2,6 +2,11 @@ export function renderDoctorResult(result) {
   const lines = [`testkit doctor ${result.ok ? "passed" : "failed"} for ${result.productDir}`];
   for (const check of result.checks || []) {
     lines.push(`${check.level.toUpperCase()} ${check.code} ${check.message}`);
+    for (const detail of (check.details || []).slice(0, 5)) {
+      if (detail?.ruleId) {
+        lines.push(`  ${detail.ruleId} ${detail.file}:${detail.line} ${detail.message}`);
+      }
+    }
   }
   return lines;
 }

package/lib/cli/renderers/lint/text.mjs

@@ -0,0 +1,20 @@
+export function renderLintResult(result) {
+  const lines = [
+    `testkit lint ${result.ok ? "passed" : "failed"} for ${result.productDir}`,
+    `Checked ${result.summary.files} source file(s), ${result.summary.testkitFiles} testkit suite file(s).`,
+  ];
+
+  if (result.violations.length === 0) {
+    return lines;
+  }
+
+  lines.push("");
+  for (const violation of result.violations) {
+    const location = violation.line ? `${violation.file}:${violation.line}` : violation.file;
+    lines.push(`${location} ${violation.ruleId}: ${violation.message}`);
+    if (violation.snippet) {
+      lines.push(`  ${violation.snippet}`);
+    }
+  }
+  return lines;
+}

package/lib/config/index.mjs

@@ -167,6 +167,7 @@ function normalizeServiceConfig({
       skip,
       runtime,
       browser,
+      ui: config.ui || null,
       fileMetadataByPath: serviceFileMetadata,
       local,
     },

package/lib/config-api/database-steps.mjs

@@ -0,0 +1,340 @@
+import { execa } from "execa";
+
+export async function verifySeed(context = {}) {
+  const args = context.args || {};
+  const table = requireIdentifier(args.table, "verifySeed.args.table");
+  const where = normalizeOptionalSql(args.where);
+  const minRows = normalizeNonNegativeInteger(args.minRows ?? 1, "verifySeed.args.minRows");
+  const databaseUrl = requireDatabaseUrl(context);
+  const query = `select count(*)::int from ${table}${where ? ` where ${where}` : ""}`;
+  const count = Number(await runScalar(databaseUrl, query, context));
+
+  if (!Number.isInteger(count) || count < minRows) {
+    throw new Error(`Expected at least ${minRows} row(s) in ${table}, found ${count || 0}`);
+  }
+}
+
+export async function verifyRows(context = {}) {
+  const args = context.args || {};
+  const checks = Array.isArray(args.checks) ? args.checks : [args];
+  const databaseUrl = requireDatabaseUrl(context);
+  const failures = [];
+
+  for (const [index, check] of checks.entries()) {
+    const label = `verifyRows.args.checks[${index}]`;
+    const table = requireIdentifier(check.table, `${label}.table`);
+    const where = normalizeOptionalSql(check.where);
+    const minRows = normalizeNonNegativeInteger(check.minRows ?? 1, `${label}.minRows`);
+    const severity = check.severity === "warn" ? "warn" : "error";
+    const query = `select count(*)::int from ${table}${where ? ` where ${where}` : ""}`;
+    const count = Number(await runScalar(databaseUrl, query, context));
+
+    if (!Number.isInteger(count) || count < minRows) {
+      const message = `Expected at least ${minRows} row(s) in ${table}, found ${count || 0}`;
+      if (severity === "warn") {
+        console.warn(message);
+      } else {
+        failures.push(message);
+      }
+    }
+  }
+
+  if (failures.length > 0) {
+    throw new Error(`Database row verification failed:\n${failures.map((failure) => `- ${failure}`).join("\n")}`);
+  }
+}
+
+export async function runSql(context = {}) {
+  const args = context.args || {};
+  const statements = normalizeStatementList(args.statements ?? args.statement, "runSql.args.statements");
+  const databaseUrl = requireDatabaseUrl(context);
+
+  for (const statement of statements) {
+    await runPsql(databaseUrl, statement, context);
+  }
+}
+
+export async function seedRows(context = {}) {
+  const args = context.args || {};
+  const table = requireIdentifier(args.table, "seedRows.args.table");
+  const rows = normalizeRowList(args.rows, "seedRows.args.rows");
+  const databaseUrl = requireDatabaseUrl(context);
+
+  if (args.truncate === true) {
+    await runPsql(databaseUrl, `truncate table ${table}`, context);
+  }
+
+  if (rows.length === 0) return;
+
+  const columns = normalizeSeedColumns(args.columns, rows);
+  const columnSql = columns.map((column) => requireIdentifier(column, `seedRows.args.columns.${column}`));
+  const valueGroups = rows.map((row) =>
+    `(${columns.map((column) => toSqlExpression(row[column], context)).join(", ")})`
+  );
+  await runPsql(
+    databaseUrl,
+    `insert into ${table} (${columnSql.join(", ")}) values ${valueGroups.join(", ")}`,
+    context
+  );
+}
+
+export async function materializePostgresBinding(context = {}) {
+  const args = context.args || {};
+  const table = requireIdentifier(args.table, "materializePostgresBinding.args.table");
+  const keyColumn = requireIdentifier(
+    args.keyColumn || "slug",
+    "materializePostgresBinding.args.keyColumn"
+  );
+  const key = normalizeRequiredValue(args.key, "materializePostgresBinding.args.key");
+  const values = normalizeObject(args.values, "materializePostgresBinding.args.values");
+  const databaseUrl = requireDatabaseUrl(context);
+
+  const columns = Object.keys(values);
+  if (columns.length === 0) {
+    throw new Error("materializePostgresBinding.args.values must contain at least one column");
+  }
+
+  const assignments = columns.map((column) => {
+    const identifier = requireIdentifier(column, `materializePostgresBinding.args.values.${column}`);
+    return `${identifier} = ${toSqlLiteral(values[column])}`;
+  });
+  const query =
+    `with updated as (update ${table} set ${assignments.join(", ")} ` +
+    `where ${keyColumn} = ${toSqlLiteral(key)} returning 1) select count(*)::int from updated`;
+  const result = await runPsql(databaseUrl, query, context);
+  const updated = Number(String(result.stdout || "").trim() || "0");
+  if (updated !== 1) {
+    throw new Error(`Expected to materialize 1 ${table} row for ${keyColumn}=${key}, updated ${updated || 0}`);
+  }
+}
+
+export async function updateRows(context = {}) {
+  const args = context.args || {};
+  const table = requireIdentifier(args.table, "updateRows.args.table");
+  const where = normalizeWhereObject(args.where, "updateRows.args.where");
+  const values = normalizeObject(args.values ?? args.set, "updateRows.args.values");
+  const databaseUrl = requireDatabaseUrl(context);
+  const expectRows = args.expectRows == null
+    ? null
+    : normalizeNonNegativeInteger(args.expectRows, "updateRows.args.expectRows");
+
+  const assignments = Object.keys(values).map((column) => {
+    const identifier = requireIdentifier(column, `updateRows.args.values.${column}`);
+    return `${identifier} = ${toSqlExpression(values[column], context)}`;
+  });
+  if (assignments.length === 0) {
+    throw new Error("updateRows.args.values must contain at least one column");
+  }
+
+  const query =
+    `with updated as (update ${table} set ${assignments.join(", ")} ` +
+    `where ${buildWhereClause(where, context)} returning 1) select count(*)::int from updated`;
+  const result = await runPsql(databaseUrl, query, context);
+  const updated = Number(String(result.stdout || "").trim() || "0");
+  if (expectRows !== null && updated !== expectRows) {
+    throw new Error(`Expected to update ${expectRows} ${table} row(s), updated ${updated || 0}`);
+  }
+}
+
+function requireDatabaseUrl(context) {
+  const databaseUrl = String(context.databaseUrl || context.env?.DATABASE_URL || "").trim();
+  if (!databaseUrl) {
+    throw new Error("Database template step requires DATABASE_URL");
+  }
+  return databaseUrl;
+}
+
+async function runScalar(databaseUrl, query, context) {
+  const result = await runPsql(databaseUrl, query, context);
+  return String(result.stdout || "").trim();
+}
+
+async function runPsql(databaseUrl, query, context) {
+  const result = await execa(
+    "psql",
+    [
+      databaseUrl,
+      "-v",
+      "ON_ERROR_STOP=1",
+      "-X",
+      "-q",
+      "-t",
+      "-A",
+      "-c",
+      query,
+    ],
+    {
+      cwd: context.cwd || context.productDir || process.cwd(),
+      env: context.env || process.env,
+      stdout: "pipe",
+      stderr: "pipe",
+      reject: false,
+    }
+  );
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr || result.shortMessage || `psql failed with exit code ${result.exitCode}`);
+  }
+  return result;
+}
+
+function normalizeStatementList(value, label) {
+  const values = Array.isArray(value) ? value : value == null ? [] : [value];
+  if (values.length === 0) {
+    throw new Error(`${label} must contain at least one SQL statement`);
+  }
+  return values.map((statement, index) => {
+    const normalized = String(statement || "").trim();
+    if (!normalized || /;\s*\S/.test(normalized)) {
+      throw new Error(`${label}[${index}] must be one SQL statement`);
+    }
+    return normalized;
+  });
+}
+
+function normalizeRowList(value, label) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${label} must be an array`);
+  }
+  return value.map((row, index) => normalizeObject(row, `${label}[${index}]`));
+}
+
+function normalizeSeedColumns(value, rows) {
+  if (value != null) {
+    if (!Array.isArray(value) || value.length === 0) {
+      throw new Error("seedRows.args.columns must be a non-empty array");
+    }
+    return value.map((column) => String(column));
+  }
+  return [...new Set(rows.flatMap((row) => Object.keys(row)))].sort((left, right) => left.localeCompare(right));
+}
+
+function normalizeWhereObject(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0) {
+    throw new Error(`${label} must contain at least one column`);
+  }
+  return value;
+}
+
+function buildWhereClause(where, context) {
+  return Object.entries(where)
+    .map(([column, value]) => `${requireIdentifier(column, `where.${column}`)} = ${toSqlExpression(value, context)}`)
+    .join(" and ");
+}
+
+function requireIdentifier(value, label) {
+  const normalized = String(value || "").trim();
+  if (!/^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)?$/.test(normalized)) {
+    throw new Error(`${label} must be a SQL identifier or schema-qualified identifier`);
+  }
+  return normalized;
+}
+
+function normalizeOptionalSql(value) {
+  if (value == null || value === "") return "";
+  const normalized = String(value).trim();
+  if (!normalized || /;|--|\/\*/.test(normalized)) {
+    throw new Error("verifySeed.args.where must be a single SQL predicate without comments or semicolons");
+  }
+  return normalized;
+}
+
+function normalizeNonNegativeInteger(value, label) {
+  const normalized = Number(value);
+  if (!Number.isInteger(normalized) || normalized < 0) {
+    throw new Error(`${label} must be a non-negative integer`);
+  }
+  return normalized;
+}
+
+function normalizeObject(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+
+function normalizeRequiredValue(value, label) {
+  if (value == null || String(value).length === 0) {
+    throw new Error(`${label} is required`);
+  }
+  return value;
+}
+
+function toSqlLiteral(value) {
+  if (value === null) return "null";
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  return `'${String(value).replaceAll("'", "''")}'`;
+}
+
+function toSqlExpression(value, context) {
+  if (!isValueDescriptor(value)) return toSqlLiteral(value);
+  switch (value.kind) {
+    case "now":
+      return "now()";
+    case "env":
+      return toSqlLiteral(readRequiredEnv(context.env || process.env, value.name));
+    case "json":
+      return `${toSqlLiteral(JSON.stringify(resolveJsonValue(value.value, context)))}::jsonb`;
+    case "postgres-connection-from-env":
+      return `${toSqlLiteral(JSON.stringify(buildPostgresConnectionFromEnv(context.env || process.env, value.prefix)))}::jsonb`;
+    default:
+      throw new Error(`Unsupported database value descriptor "${value.kind}"`);
+  }
+}
+
+function isValueDescriptor(value) {
+  return value && typeof value === "object" && !Array.isArray(value) && typeof value.kind === "string";
+}
+
+function resolveJsonValue(value, context) {
+  if (Array.isArray(value)) return value.map((entry) => resolveJsonValue(entry, context));
+  if (!value || typeof value !== "object") return value;
+  if (isValueDescriptor(value)) {
+    if (value.kind === "env") return readRequiredEnv(context.env || process.env, value.name);
+    if (value.kind === "postgres-connection-from-env") {
+      return buildPostgresConnectionFromEnv(context.env || process.env, value.prefix);
+    }
+  }
+  return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, resolveJsonValue(entry, context)]));
+}
+
+function buildPostgresConnectionFromEnv(env, prefix) {
+  const normalizedPrefix = String(prefix || "").trim();
+  if (!normalizedPrefix) {
+    throw new Error("postgresConnectionFromEnv requires a non-empty prefix");
+  }
+  return {
+    host: readRequiredEnv(env, `${normalizedPrefix}_HOST`),
+    port: readRequiredPort(env, `${normalizedPrefix}_PORT`),
+    database: readRequiredEnv(env, `${normalizedPrefix}_NAME`),
+    username: readRequiredEnv(env, `${normalizedPrefix}_USER`),
+    password: readRequiredEnv(env, `${normalizedPrefix}_PASSWORD`),
+    ssl: parseBooleanEnv(env[`${normalizedPrefix}_SSL`]),
+  };
+}
+
+function readRequiredEnv(env, name) {
+  const value = env?.[name];
+  if (value == null || String(value).trim().length === 0) {
+    throw new Error(`${name} environment variable is required`);
+  }
+  return String(value).trim();
+}
+
+function readRequiredPort(env, name) {
+  const value = Number.parseInt(readRequiredEnv(env, name), 10);
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+  return value;
+}
+
+function parseBooleanEnv(value) {
+  if (!value) return false;
+  return ["1", "true", "yes", "on"].includes(String(value).trim().toLowerCase());
+}