GITHUB_TOKEN="op://Work/repo-name/wrxqfrltnqlzgako6zx6fjak6m/GITHUB_TOKEN"
TF_VAR_github_app_private_key="op://Work/repo-name/private key"
TF_VAR_crowdin_token="op://Work/repo-name/CROWDIN_PERSONAL_TOKEN/value"
TF_VAR_discord_webhook="op://Work/repo-name/DISCORD_WEBHOOK_URL/value"
TF_VAR_rclone_config="op://Work/repo-name/RCLONE_CONFIG/value"

op run --env-file=".env" -- terraform apply

docker sandbox run claude

type Foo = { a: string; b: number };
type Bar = { a: string; b: number };

const foo: Foo = { a: '42', b: 42 };
const bar: Bar = foo;

type Params = { fieldA: number; fieldB: number } // те, шо мені треба
type Whatever = { megaFieldA: number; megaFieldB: number }; // якийсь інший тип

func(whateverObj, { fieldA: 'megaFieldA', fieldB: 'megaFieldB' });

type MyKeyMap<SourceType> = Partial<{
    [K in keyof Params]: keyof SourceType;
}>;

let foo = {};
foo[someVal + 1] = 'blabla';

const foo = { [someVal + 1]: 'blabla' };

procedure Set_Speed (S : in out Speed_Knots; New_Value : Speed_Knots)
  with
    Pre  => New_Value >= 0.0 and New_Value <= 1000.0,
    Post => S = New_Value;

void set_speed(speed_knots & s, speed_knots new_value)
  pre(new_value >= 0.0 && new_value <= 1000.0)
  post(s == new_value);

auto calculate(auto && val) post(r: is_valid(r));

template <std::floating_point T>
constexpr auto normalize(std::array<T, 3> vector) noexcept -> std::array<T, 3>
  pre(is_normalizable(vector))
  post(vector: is_normalized(vector))
{
  auto& [x, y, z]{vector};
  const auto norm{std::hypot(x, y, z)};
  
  x /= norm, y /= norm, z /= norm;
  
  return vector;
}

template <typename... Ts> void print_all(Ts... elems);

print_all("foo", 42, 'p', 3.14); // використання

template <typename... Ts> 
void print_all(Ts... elems) 
{ 
  (std::println("{}", elems), ...); 
}

void print_all() {}

template <typename T, typename... Ts>
void print_all(T first, Ts... rest) {
    std::cout << first << std::endl;
    print_all(rest...);
}

template <typename... Ts>
void print_all(Ts... elems) {
  template for (auto elem : {elems...}) {
    std::println("{}", elem);
  }
}

template <typename... Ts>
void print_all(Ts... elems) {
  {
    {
      auto elem = elems...[0];  // така індексація, 
                                // до речі, також
                                // нова фіча
      std::println("{}", elem);
    }
    {
      auto elem = elems...[1];
      std::println("{}", elem);
    }
    {
      auto elem = elems...[2];
      std::println("{}", elem);
    }
  }
}

void f() {
  template for (constexpr int I : std::array{1, 2, 3}) {
    static_assert(I < 4);
  }
}

void f() {
  {
    constexpr auto&& __range = std::array{1, 2, 3};
    constexpr auto __begin = __range.begin();
    constexpr auto __expansion_size = __range.end() - __begin; // 3

    {
      constexpr int I = *(__begin + 0);
      static_assert(I < 4);
    }

    {
      constexpr int I = *(__begin + 1);
      static_assert(I < 4);
    }

    {
      constexpr int I = *(__begin + 2);
      static_assert(I < 4);
    }
  }
}

void foo() {
  int d;   // не ініціалізуємо
  bar(d);  // хоба! — не UB
}

void foo() {
  int d [[indeterminate]];
  bar(d);  // Фух, старий-добрий UB :)
}

int arr1[5];
int arr2[5];
bool same = arr1 == arr2;  // тепер помилка

int arr1[5];
int arr2[5];
bool same = arr1 == +arr2;  // працює

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "lmstudio": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "LM Studio (local)",
      "options": {
        "baseURL": "http://127.0.0.1:1234/v1"
      },
      "models": {
        "google/gemma-4-26b-a4b": {
          "name": "Gemma 4 26B A4B"
        }
      }
    }
  }
}

opencode -m google/gemma-4-26b-a4b