public static void WriteAllTextAtomic(string path, string content, Encoding? encoding = null)
{
    encoding ??= new UTF8Encoding(false);
    var fullPath = Path.GetFullPath(path);
    Directory.CreateDirectory(Path.GetDirectoryName(fullPath)!);
    var tempPath = fullPath + "." + Guid.NewGuid().ToString("N") + ".tmp";
    try
    {
        File.WriteAllText(tempPath, content, encoding);
        File.Move(tempPath, fullPath, true);
    }
    finally
    {
        if (File.Exists(tempPath)) File.Delete(tempPath);
    }
}

public static string Sha256File(string path)
{
    using var stream = File.OpenRead(path);
    using var sha = SHA256.Create();
    return Convert.ToHexString(sha.ComputeHash(stream)).ToLowerInvariant();
}

public static string SafeChildPath(string root, string relativePath)
{
    var rootPath = Path.GetFullPath(root).TrimEnd(Path.DirectorySeparatorChar) + Path.DirectorySeparatorChar;
    var candidate = Path.GetFullPath(Path.Combine(rootPath, relativePath));
    if (!candidate.StartsWith(rootPath, StringComparison.OrdinalIgnoreCase))
        throw new UnauthorizedAccessException("Path escapes the approved root.");
    return candidate;
}

public static async Task<T> GetJsonAsync<T>(HttpClient client, string url, CancellationToken token)
{
    using var response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, token);
    var body = await response.Content.ReadAsStringAsync(token);
    if (!response.IsSuccessStatusCode)
        throw new HttpRequestException($"HTTP {(int)response.StatusCode}: {body}");
    return JsonSerializer.Deserialize<T>(body, new JsonSerializerOptions
    {
        PropertyNameCaseInsensitive = true
    }) ?? throw new JsonException("The response body was empty.");
}

public static async Task<T> RetryAsync<T>(Func<CancellationToken, Task<T>> action, int attempts, CancellationToken token)
{
    if (attempts < 1) throw new ArgumentOutOfRangeException(nameof(attempts));
    Exception? last = null;
    for (var attempt = 1; attempt <= attempts; attempt++)
    {
        try { return await action(token); }
        catch (Exception ex) when (attempt < attempts && ex is not OperationCanceledException)
        {
            last = ex;
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt - 1)), token);
        }
    }
    throw last ?? new InvalidOperationException("Retry failed.");
}

public static string CsvRow(IEnumerable<object?> values)
{
    return string.Join(",", values.Select(value =>
    {
        var text = Convert.ToString(value, CultureInfo.InvariantCulture) ?? string.Empty;
        return text.IndexOfAny(new[] { ',', '"', '\r', '\n' }) >= 0
            ? "\"" + text.Replace("\"", "\"\"") + "\""
            : text;
    }));
}

public static IEnumerable<IReadOnlyList<T>> Batch<T>(IEnumerable<T> source, int size)
{
    if (size <= 0) throw new ArgumentOutOfRangeException(nameof(size));
    var batch = new List<T>(size);
    foreach (var item in source)
    {
        batch.Add(item);
        if (batch.Count != size) continue;
        yield return batch;
        batch = new List<T>(size);
    }
    if (batch.Count > 0) yield return batch;
}

public static T? GetNullable<T>(this IDataRecord record, string column) where T : struct
{
    var ordinal = record.GetOrdinal(column);
    if (record.IsDBNull(ordinal)) return null;
    return (T)Convert.ChangeType(record.GetValue(ordinal), typeof(T), CultureInfo.InvariantCulture);
}

public static XDocument LoadXmlSecure(Stream input)
{
    var settings = new XmlReaderSettings
    {
        DtdProcessing = DtdProcessing.Prohibit,
        XmlResolver = null,
        MaxCharactersInDocument = 20_000_000
    };
    using var reader = XmlReader.Create(input, settings);
    return XDocument.Load(reader, LoadOptions.None);
}

public static async Task CopyWithProgressAsync(Stream source, Stream target, IProgress<long>? progress, CancellationToken token)
{
    var buffer = new byte[81920];
    long total = 0;
    int read;
    while ((read = await source.ReadAsync(buffer.AsMemory(0, buffer.Length), token)) > 0)
    {
        await target.WriteAsync(buffer.AsMemory(0, read), token);
        total += read;
        progress?.Report(total);
    }
}

Public Sub WriteAllTextAtomic(path As String, content As String)
    Dim fullPath = IO.Path.GetFullPath(path)
    IO.Directory.CreateDirectory(IO.Path.GetDirectoryName(fullPath))
    Dim tempPath = fullPath & "." & Guid.NewGuid().ToString("N") & ".tmp"
    Try
        IO.File.WriteAllText(tempPath, content, New Text.UTF8Encoding(False))
        IO.File.Move(tempPath, fullPath, True)
    Finally
        If IO.File.Exists(tempPath) Then IO.File.Delete(tempPath)
    End Try
End Sub

Public Function Sha256File(path As String) As String
    Using stream = IO.File.OpenRead(path), sha = Security.Cryptography.SHA256.Create()
        Return Convert.ToHexString(sha.ComputeHash(stream)).ToLowerInvariant()
    End Using
End Function

Public Function GetNullableString(record As IDataRecord, column As String) As String
    Dim ordinal = record.GetOrdinal(column)
    If record.IsDBNull(ordinal) Then Return Nothing
    Return record.GetString(ordinal)
End Function

Public Function SafeChildPath(root As String, relativePath As String) As String
    Dim rootPath = IO.Path.GetFullPath(root).TrimEnd(IO.Path.DirectorySeparatorChar) & IO.Path.DirectorySeparatorChar
    Dim candidate = IO.Path.GetFullPath(IO.Path.Combine(rootPath, relativePath))
    If Not candidate.StartsWith(rootPath, StringComparison.OrdinalIgnoreCase) Then
        Throw New UnauthorizedAccessException("Path escapes the approved root.")
    End If
    Return candidate
End Function

Public Function ReadJsonFile(Of T)(path As String) As T
    Dim json = IO.File.ReadAllText(path, Text.Encoding.UTF8)
    Dim options = New Text.Json.JsonSerializerOptions With {.PropertyNameCaseInsensitive = True}
    Dim value = Text.Json.JsonSerializer.Deserialize(Of T)(json, options)
    If value Is Nothing Then Throw New Text.Json.JsonException("JSON produced no value.")
    Return value
End Function

add_action('admin_post_jvr_save_item', function () {
    if (!current_user_can('manage_options')) {
        wp_die('Not allowed.', 403);
    }
    check_admin_referer('jvr_save_item');
    $name = isset($_POST['name']) ? sanitize_text_field(wp_unslash($_POST['name'])) : '';
    if ($name === '') {
        wp_safe_redirect(add_query_arg('error', 'missing_name', wp_get_referer()));
        exit;
    }
    update_option('jvr_item_name', $name, false);
    wp_safe_redirect(add_query_arg('updated', '1', wp_get_referer()));
    exit;
});

add_action('rest_api_init', function () {
    register_rest_route('jvr/v1', '/status', array(
        'methods' => WP_REST_Server::READABLE,
        'callback' => function () {
            return rest_ensure_response(array('ok' => true, 'time' => current_time('mysql')));
        },
        'permission_callback' => function () {
            return current_user_can('manage_options');
        },
    ));
});

function jvr_recent_job_ids() {
    $key = 'jvr_recent_job_ids_v1';
    $ids = get_transient($key);
    if ($ids !== false) return $ids;
    $ids = get_posts(array(
        'post_type' => 'post', 'post_status' => 'publish',
        'posts_per_page' => 50, 'fields' => 'ids', 'no_found_rows' => true,
    ));
    set_transient($key, $ids, 10 * MINUTE_IN_SECONDS);
    return $ids;
}

from pathlib import Path
import json, os, tempfile

def save_json_atomic(path, value):
    target = Path(path).resolve()
    target.parent.mkdir(parents=True, exist_ok=True)
    fd, temp = tempfile.mkstemp(dir=target.parent, prefix=target.name + ".", suffix=".tmp")
    try:
        with os.fdopen(fd, "w", encoding="utf-8") as handle:
            json.dump(value, handle, ensure_ascii=False, indent=2)
            handle.flush(); os.fsync(handle.fileno())
        os.replace(temp, target)
    finally:
        if os.path.exists(temp): os.unlink(temp)

import time

def retry(action, attempts=4, retry_if=lambda exc: True):
    if attempts < 1:
        raise ValueError("attempts must be positive")
    for attempt in range(attempts):
        try:
            return action()
        except Exception as exc:
            if attempt + 1 == attempts or not retry_if(exc):
                raise
            time.sleep(2 ** attempt)

export async function fetchWithTimeout(url, options = {}, timeoutMs = 10000) {
  const timeout = AbortSignal.timeout(timeoutMs);
  const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
  const response = await fetch(url, { ...options, signal });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  return response;
}

export function debounce(callback, delay = 250) {
  let timer;
  return function (...args) {
    clearTimeout(timer);
    timer = setTimeout(() => callback.apply(this, args), delay);
  };
}

export async function copyText(text) {
  if (navigator.clipboard && window.isSecureContext) {
    await navigator.clipboard.writeText(text);
    return;
  }
  const area = Object.assign(document.createElement('textarea'), { value: text });
  area.style.position = 'fixed'; area.style.opacity = '0';
  document.body.append(area); area.select();
  try { document.execCommand('copy'); } finally { area.remove(); }
}

function Invoke-WithRetry {
    param([Parameter(Mandatory)][scriptblock]$Action, [int]$Attempts = 4)
    for ($attempt = 1; $attempt -le $Attempts; $attempt++) {
        try { return & $Action }
        catch {
            if ($attempt -eq $Attempts) { throw }
            Start-Sleep -Seconds ([math]::Pow(2, $attempt - 1))
        }
    }
}

param([Parameter(Mandatory)][string]$Root)
$resolved = (Resolve-Path -LiteralPath $Root).Path
Get-ChildItem -LiteralPath $resolved -File -Recurse |
    Sort-Object FullName |
    ForEach-Object {
        [pscustomobject]@{
            Path = $_.FullName.Substring($resolved.Length).TrimStart('\')
            SHA256 = (Get-FileHash -LiteralPath $_.FullName -Algorithm SHA256).Hash.ToLowerInvariant()
        }
    }

INSERT INTO app_settings (setting_key, setting_value, updated_at)
VALUES (?, ?, UTC_TIMESTAMP())
ON DUPLICATE KEY UPDATE
    setting_value = VALUES(setting_value),
    updated_at = VALUES(updated_at);