chore: update ignore rules

feat(v0.1.58): ImageExists cache hit, timing analysis, in-cluster registry plan
2026-10-27 14:19:58 +03:00 · 2026-10-27 14:09:07 +03:00 · 2026-03-23 06:22:25 +03:00 · 2026-03-22 17:51:05 +03:00 · 2026-03-22 17:28:40 +03:00 · 2026-03-22 17:04:01 +04:00
59 changed files with 1448 additions and 1492 deletions
@@ -75,3 +75,4 @@ examples/POSTGRES/stress_log*.txt
 /s3cfg_registry
 /sqs-operator/quick_test.sh
 /sqs-operator/sqs_load_test.sh
+/.s3cfg_registry
@@ -115,12 +115,7 @@ func (r *FunctionReconciler) startBuild(ctx context.Context, fn *slessv1alpha1.F

 	// Проверяем: образ с этим тегом уже существует в registry?
 	// Если да — пропускаем kaniko, сразу переходим в Ready.
-	// Если registry недоступен — requeue, не запускаем сборку (kaniko тоже упадёт).
-	exists, err := r.Builder.ImageExists(ctx, imageRef)
-	if err != nil {
-		return ctrl.Result{RequeueAfter: 10 * time.Second}, fmt.Errorf("check image exists: %w", err)
-	}
-	if exists {
+	if r.Builder.ImageExists(ctx, imageRef) {
 		logger := log.FromContext(ctx)
 		logger.Info("image already exists in registry, skipping build", "imageRef", imageRef)

@@ -124,12 +124,7 @@ func (r *FunctionJobReconciler) startJobBuild(ctx context.Context, fj *slessv1al
 	imageRef := r.Builder.ImageRef(r.OperatorNamespace, fj.Name, fj.Spec.S3Key)

 	// Проверяем: образ с этим тегом уже существует в registry?
-	// Если registry недоступен — requeue, не запускаем сборку.
-	exists, err := r.Builder.ImageExists(ctx, imageRef)
-	if err != nil {
-		return ctrl.Result{RequeueAfter: 10 * time.Second}, fmt.Errorf("check image exists: %w", err)
-	}
-	if exists {
+	if r.Builder.ImageExists(ctx, imageRef) {
 		logger.Info("image already exists in registry, skipping build", "imageRef", imageRef)

 		if fj.Annotations == nil {
@@ -109,12 +109,7 @@ func (r *ServiceReconciler) startServiceBuild(ctx context.Context, svc *slessv1a

 	// Проверяем: образ с этим тегом уже существует в registry?
 	// Если да — пропускаем kaniko, сразу переходим в Ready с известным imageRef.
-	// Если registry недоступен — requeue, не запускаем сборку (kaniko тоже упадёт).
-	exists, err := r.Builder.ImageExists(ctx, imageRef)
-	if err != nil {
-		return ctrl.Result{RequeueAfter: 10 * time.Second}, fmt.Errorf("check image exists: %w", err)
-	}
-	if exists {
+	if r.Builder.ImageExists(ctx, imageRef) {
 		logger := log.FromContext(ctx)
 		logger.Info("image already exists in registry, skipping build", "imageRef", imageRef)

@@ -4,39 +4,6 @@

 ---

-## 2026-03-23 — Сессия 11: Баги cache-тест, fix оператора v0.1.62, fix провайдера
-
-### Что сделано
-
-**Bug 1: Go 1.23 go.work + replace конфликт (FIXED → v0.1.61)**
- `internal/builder/context.go`: убран `replace sless/fn/handler => ./handler` из go.work шаблона
- Добавлен `sed` переименования модуля вместо replace
- Ошибка была: `go: workspace module sless/fn/handler is replaced at all versions in the go.work file`
-
-**Bug 2: controller-runtime cache lag → 404 на upload (FIXED → v0.1.62)**
- `internal/api/handler/services.go`: retry loop 5×200ms в `UploadServiceCode`
- `internal/api/handler/jobs.go`: retry loop 5×200ms в `UploadJobCode`
- Причина: сразу после POST /services (201) informer cache ещё не синхронизирован → IsNotFound
-
-**Bug 3: Провайдер — 409 при повторном apply после сбоя upload (FIXED)**
- `terraform/provider/internal/resources/service_resource.go`: в `Create()` при ошибке upload — rollback `DeleteService()`
- `terraform/provider/internal/resources/job_resource.go`: аналогично `DeleteJob()`
- Причина: upload в S3 падал (сетевой сбой), terraform не записывал state, CR оставался в k8s → следующий apply получал 409
-
-**test_cache_matrix.sh v4**
- Убраны все `-target` из скрипта — terraform не должен касаться postgres при частичных операциях
- `destroy_sless_only()`: переименует `chaos_marathon.tf`, `functions.tf`, `stress.tf` → `.bak`, делает apply (terraform сам удаляет), возвращает файлы
- Phase 3a: закомментирует блоки ресурсов через Python вместо `-target`
-
-**Operator v0.1.62** собран и задеплоен (`naeel/sless-operator:v0.1.62`)
-
-### Статус
-✅ v0.1.62 Running  
-✅ Провайдер пересобран на VM (`/tmp/sless-provider-dev/`)  
-⏳ test_cache_matrix.sh v4 — Phase 1 в процессе (pg-stats удалили вручную, apply идёт)
-
---
-
 ## 2026-03-23 — Сессия 10: ImageExists + деплой v0.1.58

 ### Что сделано
@@ -0,0 +1,257 @@
+// 2026-03-21 — chaos_marathon.tf: 15 новых сервисов для часового хаос-марафона.
+// Два рантайма: python3.11 (9), nodejs20 (2).
+// Все зависят от sless_job.postgres_table_init_job.
+
+# ── Python: работа с таблицей ─────────────────────────────────────────────────
+
+# Считает строки по prefix — тест concurrent reads + COUNT агрегации.
+resource "sless_service" "pg_counter" {
+  name        = "pg-counter"
+  runtime     = "python3.11"
+  entrypoint  = "pg_counter.count"
+  memory_mb   = 128
+  timeout_sec = 15
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  source_dir = "${path.module}/code/pg-counter"
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# DELETE дублей по title — идемпотентный, повторный вызов безопасен.
+resource "sless_service" "pg_dedup" {
+  name        = "pg-dedup"
+  runtime     = "python3.11"
+  entrypoint  = "pg_dedup.dedup"
+  memory_mb   = 128
+  timeout_sec = 30
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  source_dir = "${path.module}/code/pg-dedup"
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# Поиск по title с ILIKE + пагинация — тест спецсимволов и SQL injection safety.
+resource "sless_service" "pg_search" {
+  name        = "pg-search"
+  runtime     = "python3.11"
+  entrypoint  = "pg_search.search"
+  memory_mb   = 128
+  timeout_sec = 15
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  source_dir = "${path.module}/code/pg-search"
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# Bulk INSERT через execute_values — до 500 строк за раз.
+resource "sless_service" "pg_bulk_insert" {
+  name        = "pg-bulk-insert"
+  runtime     = "python3.11"
+  entrypoint  = "pg_bulk_insert.bulk_insert"
+  memory_mb   = 256
+  timeout_sec = 30
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  source_dir = "${path.module}/code/pg-bulk-insert"
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# DELETE строк старше N минут — идемпотентный.
+resource "sless_service" "pg_delete_old" {
+  name        = "pg-delete-old"
+  runtime     = "python3.11"
+  entrypoint  = "pg_delete_old.delete_old"
+  memory_mb   = 128
+  timeout_sec = 30
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  source_dir = "${path.module}/code/pg-delete-old"
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# INSERT ON CONFLICT DO UPDATE — повторный вызов с тем же title безопасен.
+resource "sless_service" "pg_upsert" {
+  name        = "pg-upsert"
+  runtime     = "python3.11"
+  entrypoint  = "pg_upsert.upsert"
+  memory_mb   = 128
+  timeout_sec = 15
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  source_dir = "${path.module}/code/pg-upsert"
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# ── Python: chaos ─────────────────────────────────────────────────────────────
+
+# Echo: принимает любой ввод и отражает обратно — проверка на мусорный input.
+resource "sless_service" "chaos_echo" {
+  name        = "chaos-echo"
+  runtime     = "python3.11"
+  entrypoint  = "chaos_echo.echo"
+  memory_mb   = 128
+  timeout_sec = 10
+
+  source_dir = "${path.module}/code/chaos-echo"
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# Валидация плохих параметров — тупой юзер не может уронить сервис.
+resource "sless_service" "chaos_badparams" {
+  name        = "chaos-badparams"
+  runtime     = "python3.11"
+  entrypoint  = "chaos_badparams.validate"
+  memory_mb   = 128
+  timeout_sec = 10
+
+  source_dir = "${path.module}/code/chaos-badparams"
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# Медленный pg_sleep — тест timeout enforcement.
+resource "sless_service" "chaos_slowquery" {
+  name        = "chaos-slowquery"
+  runtime     = "python3.11"
+  entrypoint  = "chaos_slowquery.slowquery"
+  memory_mb   = 128
+  timeout_sec = 12
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  source_dir = "${path.module}/code/chaos-slowquery"
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# Большой JSON response — тест памяти и серилизации.
+resource "sless_service" "chaos_bigpayload" {
+  name        = "chaos-bigpayload"
+  runtime     = "python3.11"
+  entrypoint  = "chaos_bigpayload.bigpayload"
+  memory_mb   = 256
+  timeout_sec = 15
+
+  source_dir = "${path.module}/code/chaos-bigpayload"
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# ── Node.js ───────────────────────────────────────────────────────────────────
+
+# Bulk INSERT через параметризованный multi-value query.
+resource "sless_service" "js_pg_batch" {
+  name        = "js-pg-batch"
+  runtime     = "nodejs20"
+  entrypoint  = "js_pg_batch.run"
+  memory_mb   = 128
+  timeout_sec = 30
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  source_dir = "${path.module}/code/js-pg-batch"
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# Идемпотентный INSERT — повторный вызов с тем же key = existing, не дубль.
+resource "sless_service" "js_idempotent" {
+  name        = "js-idempotent"
+  runtime     = "nodejs20"
+  entrypoint  = "js_idempotent.run"
+  memory_mb   = 128
+  timeout_sec = 15
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  source_dir = "${path.module}/code/js-idempotent"
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# ── Python: retry ─────────────────────────────────────────────────────────────
+
+# Запись с retry при transient PG error — тест устойчивости к сбоям.
+resource "sless_service" "py_retry_writer" {
+  name        = "py-retry-writer"
+  runtime     = "python3.11"
+  entrypoint  = "py_retry_writer.retry_write"
+  memory_mb   = 128
+  timeout_sec = 30
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  source_dir = "${path.module}/code/py-retry-writer"
+  depends_on = [sless_job.postgres_table_init_job]
+}
@@ -0,0 +1,40 @@
+# 2026-03-21 — chaos-badparams: проверяет что функция не падает на мусорных входных данных.
+# Принимает type=missing|wrong_type|huge|negative|zero и возвращает safe-ответ.
+# Тестирует: устойчивость к "тупому юзеру" — никакого 500 на плохих входных данных.
+import json
+
+_MAX_N = 10_000
+
+def validate(event):
+    errors = []
+    results = {}
+
+    # n: должно быть int от 1 до MAX_N
+    raw_n = event.get("n")
+    try:
+        n = int(raw_n)
+        if n <= 0:
+            errors.append(f"n must be > 0, got {n}")
+            n = 1
+        elif n > _MAX_N:
+            errors.append(f"n capped from {n} to {_MAX_N}")
+            n = _MAX_N
+    except (TypeError, ValueError):
+        errors.append(f"n is not a valid int: {repr(raw_n)}, using default 1")
+        n = 1
+    results["n"] = n
+
+    # name: обрезаем до 100 символов
+    raw_name = event.get("name", "")
+    if not isinstance(raw_name, str):
+        raw_name = str(raw_name)
+        errors.append("name was not a string, converted")
+    name = raw_name[:100]
+    results["name"] = name
+
+    # flag: любое "truthy" значение
+    raw_flag = event.get("flag", False)
+    flag = raw_flag in (True, "true", "1", 1, "yes")
+    results["flag"] = flag
+
+    return {"ok": len(errors) == 0, "errors": errors, "results": results}
@@ -0,0 +1,27 @@
+# 2026-03-21 — chaos-bigpayload: генерирует/принимает большой JSON.
+# Тестирует: большие ответы (64KB+), память рантайма.
+import json, time
+
+def bigpayload(event):
+    size_kb = min(int(event.get("size_kb", 16)), 256)   # cap 256KB
+    word = str(event.get("word", "x"))[:32]
+
+    # Генерируем список строк нужного размера
+    chunk = word * 32   # ~32+ байт на запись
+    items = []
+    total = 0
+    target = size_kb * 1024
+    i = 0
+    while total < target:
+        entry = f"{chunk}-{i}"
+        items.append(entry)
+        total += len(entry) + 3   # 3 байта JSON overhead
+        i += 1
+
+    return {
+        "items_count": len(items),
+        "size_kb_approx": round(total / 1024, 1),
+        "first": items[0] if items else "",
+        "last": items[-1] if items else "",
+        "ts": int(time.time()),
+    }
@@ -0,0 +1,19 @@
+# 2026-03-21 — chaos-echo: отражает входные данные обратно.
+# Тестирует: большие payload, unicode, null, вложенные структуры, спецсимволы.
+# "Тупой юзер" шлёт всё что угодно — функция должна вернуть это обратно без падения.
+import json
+
+def echo(event):
+    # Пытаемся сериализовать обратно — выловит непериализуемые типы
+    try:
+        size = len(json.dumps(event))
+    except Exception:
+        size = -1
+
+    keys = list(event.keys()) if isinstance(event, dict) else []
+    return {
+        "echo": event,
+        "keys": keys,
+        "size_bytes": size,
+        "type": type(event).__name__,
+    }
@@ -0,0 +1,19 @@
+# 2026-03-21 — chaos-slowquery: намеренно медленный запрос через pg_sleep.
+# Тестирует: timeout enforcement — платформа должна прервать запрос если > timeout_sec.
+# sleep_sec cap = 8 (меньше timeout_sec=10 сервиса → успех; >10 → таймаут платформы).
+import os, psycopg2
+
+def slowquery(event):
+    sleep_sec = min(float(event.get("sleep_sec", 2.0)), 8.0)
+    conn = psycopg2.connect(
+        host=os.environ["PGHOST"], port=int(os.environ.get("PGPORT", 5432)),
+        dbname=os.environ["PGDATABASE"], user=os.environ["PGUSER"],
+        password=os.environ["PGPASSWORD"], sslmode=os.environ.get("PGSSLMODE", "require"),
+    )
+    try:
+        with conn.cursor() as cur:
+            cur.execute("SELECT pg_sleep(%s), now()::text", (sleep_sec,))
+            result = cur.fetchone()
+        return {"slept_sec": sleep_sec, "pg_now": result[1]}
+    finally:
+        conn.close()
@@ -0,0 +1 @@
+psycopg2-binary
@@ -0,0 +1,94 @@
+# 2026-03-18 (обновлено: plain text вывод; фильтрация SLESS_EXCLUDE)
+# funcs_list.py — HTTP-функция: список пользовательских функций, человекочитаемый plain text.
+# Вызывает внутренний REST API оператора (ClusterIP, без TLS).
+# Возвращает str → python runtime отдаёт text/plain напрямую без json.dumps.
+#
+# Env vars:
+#   SLESS_API_URL      — URL оператора (http://sless-operator.sless.svc.cluster.local:9090)
+#   SLESS_NAMESPACE    — namespace пользователя (sless-{hex16})
+#   SLESS_TOKEN        — JWT токен для /v1/ API
+#   SLESS_EXTERNAL_URL — публичный базовый URL (https://sless.kube5s.ru)
+#   SLESS_EXCLUDE      — comma-separated имена функций, которые не показывать
+
+import os
+import requests
+
+SEP = "─" * 52
+
+
+def _comment(fn, http_trigs, cron_trigs):
+    phase   = fn.get("phase", "?")
+    runtime = fn.get("runtime", "?")
+    if http_trigs:
+        active = "активна" if http_trigs[0].get("active") else "неактивна"
+        return f"HTTP endpoint ({runtime}) — {phase}, {active}"
+    elif cron_trigs:
+        schedule = cron_trigs[0].get("schedule", "?")
+        active   = "активна" if cron_trigs[0].get("active") else "неактивна"
+        return f"Cron '{schedule}' ({runtime}) — {phase}, {active}"
+    else:
+        return f"Job/runner без триггера ({runtime}) — {phase}"
+
+
+def list_all(event):
+    api_url   = os.environ["SLESS_API_URL"].rstrip("/")
+    namespace = os.environ["SLESS_NAMESPACE"]
+    token     = os.environ["SLESS_TOKEN"]
+    ext_url   = os.environ.get("SLESS_EXTERNAL_URL", "").rstrip("/")
+    exclude   = {n.strip() for n in os.environ.get("SLESS_EXCLUDE", "").split(",") if n.strip()}
+
+    headers = {"Authorization": f"Bearer {token}"}
+    fns  = requests.get(f"{api_url}/v1/namespaces/{namespace}/functions",  headers=headers, timeout=10)
+    trs  = requests.get(f"{api_url}/v1/namespaces/{namespace}/triggers",   headers=headers, timeout=10)
+    fns.raise_for_status()
+    trs.raise_for_status()
+
+    trig_idx = {}
+    for tr in trs.json():
+        fn_name = tr.get("function") or tr.get("functionRef")
+        if fn_name:
+            trig_idx.setdefault(fn_name, []).append(tr)
+
+    items = []
+    for fn in fns.json():
+        name = fn["name"]
+        if name in exclude:
+            continue
+        http_t = [t for t in trig_idx.get(name, []) if t.get("type") == "http"]
+        cron_t = [t for t in trig_idx.get(name, []) if t.get("type") == "cron"]
+        is_active = any(t.get("enabled", True) and t.get("active", False) for t in trig_idx.get(name, []))
+        items.append((fn, http_t, cron_t, is_active))
+
+    # Сортировка: активные вверх, затем по имени
+    items.sort(key=lambda x: (not x[3], x[0]["name"]))
+
+    lines = []
+    for fn, http_t, cron_t, is_active in items:
+        name = fn["name"]
+        lines.append(SEP)
+        lines.append(f"  {_comment(fn, http_t, cron_t)}")
+        lines.append(f"  name:      {name}")
+        lines.append(f"  runtime:   {fn.get('runtime', '?')}")
+        lines.append(f"  phase:     {fn.get('phase', '?')}")
+        lines.append(f"  active:    {'да' if is_active else 'нет'}")
+
+        if http_t:
+            url = f"{ext_url}/fn/{namespace}/{name}" if ext_url else http_t[0].get("url", "")
+            lines.append(f"  url:       {url}")
+        if cron_t:
+            lines.append(f"  cron:      {cron_t[0].get('schedule', '?')}")
+        if fn.get("created_at"):
+            lines.append(f"  created:   {fn['created_at']}")
+        if fn.get("last_built_at"):
+            lines.append(f"  built:     {fn['last_built_at']}")
+        if fn.get("message"):
+            lines.append(f"  message:   {fn['message']}")
+
+    lines.append(SEP)
+    lines.append(f"  namespace: {namespace}  |  total: {len(items)}")
+    lines.append(SEP)
+
+    # Возвращаем str — python runtime отдаст text/plain напрямую
+    return "\n".join(lines) + "\n"
+
+
@@ -0,0 +1 @@
+requests==2.31.0
@@ -0,0 +1,43 @@
+// 2026-03-21 — js-pg-batch: вставляет N строк через parameterized bulk query.
+// Тестирует: async/await PG с пакетной вставкой, Node.js под нагрузкой.
+const { Client } = require('pg');
+
+async function run(event) {
+    const n = Math.min(parseInt(event.n ?? 20, 10) || 20, 200);
+    const prefix = String(event.prefix ?? 'js-batch').slice(0, 40);
+
+    const client = new Client({
+        host: process.env.PGHOST,
+        port: parseInt(process.env.PGPORT ?? '5432'),
+        database: process.env.PGDATABASE,
+        user: process.env.PGUSER,
+        password: process.env.PGPASSWORD,
+        ssl: { rejectUnauthorized: false },
+    });
+    await client.connect();
+
+    try {
+        const ts = Date.now();
+        // Строим multi-value INSERT: INSERT INTO ... VALUES ($1), ($2), ...
+        const placeholders = [];
+        const values = [];
+        for (let i = 0; i < n; i++) {
+            placeholders.push(`($${i + 1})`);
+            values.push(`${prefix}-${ts}-${i}`);
+        }
+        const sql = `INSERT INTO terraform_demo_table (title) VALUES ${placeholders.join(',')} RETURNING id`;
+        const t0 = Date.now();
+        const res = await client.query(sql, values);
+        const elapsed = (Date.now() - t0) / 1000;
+
+        return {
+            inserted: res.rowCount,
+            first_id: res.rows[0]?.id ?? null,
+            elapsed_sec: elapsed,
+        };
+    } finally {
+        await client.end();
+    }
+}
+
+module.exports = { run };
@@ -0,0 +1,7 @@
+{
+  "name": "js-pg-batch",
+  "version": "1.0.0",
+  "dependencies": {
+    "pg": "^8.11.3"
+  }
+}
@@ -0,0 +1,38 @@
+# 2026-03-21 — pg-bulk-insert: bulk INSERT через execute_values.
+# Тестирует: большие батчи (до 500 строк), производительность, память.
+import os, time, psycopg2, psycopg2.extras
+
+def bulk_insert(event):
+    try:
+        n = max(0, min(int(event.get("n", 50)), 500))  # cap 500, min 0
+    except (TypeError, ValueError):
+        n = 50
+    prefix = str(event.get("prefix", "bulk"))[:50]
+    ts = int(time.time() * 1000)
+
+    # n=0 — граничный случай: вернуть сразу без обращения к PG.
+    if n == 0:
+        return {"inserted": 0, "first_id": None, "elapsed_sec": 0.0}
+
+    rows = [(f"{prefix}-{ts}-{i}",) for i in range(n)]
+
+    conn = psycopg2.connect(
+        host=os.environ["PGHOST"], port=int(os.environ.get("PGPORT", 5432)),
+        dbname=os.environ["PGDATABASE"], user=os.environ["PGUSER"],
+        password=os.environ["PGPASSWORD"], sslmode=os.environ.get("PGSSLMODE", "require"),
+    )
+    try:
+        t0 = time.time()
+        with conn.cursor() as cur:
+            psycopg2.extras.execute_values(
+                cur,
+                "INSERT INTO terraform_demo_table (title) VALUES %s RETURNING id",
+                rows,
+                page_size=100,
+            )
+            ids = [r[0] for r in cur.fetchall()]
+        conn.commit()
+        elapsed = round(time.time() - t0, 3)
+        return {"inserted": len(ids), "first_id": ids[0] if ids else None, "elapsed_sec": elapsed}
+    finally:
+        conn.close()
@@ -0,0 +1 @@
+psycopg2-binary
@@ -0,0 +1,38 @@
+# 2026-03-21 — pg-dedup: удаляет дубликаты по title, оставляет первый (min id).
+# Тестирует: DELETE с subquery, CTE, idempotency (повторный вызов безопасен).
+import os, psycopg2
+
+def dedup(event):
+    dry_run = str(event.get("dry_run", "false")).lower() in ("true", "1", "yes")
+    conn = psycopg2.connect(
+        host=os.environ["PGHOST"], port=int(os.environ.get("PGPORT", 5432)),
+        dbname=os.environ["PGDATABASE"], user=os.environ["PGUSER"],
+        password=os.environ["PGPASSWORD"], sslmode=os.environ.get("PGSSLMODE", "require"),
+    )
+    try:
+        with conn.cursor() as cur:
+            # Считаем сколько дублей есть
+            cur.execute("""
+                SELECT COUNT(*) FROM terraform_demo_table t1
+                WHERE EXISTS (
+                    SELECT 1 FROM terraform_demo_table t2
+                    WHERE t2.title = t1.title AND t2.id < t1.id
+                )
+            """)
+            dupes_count = cur.fetchone()[0]
+
+            if not dry_run and dupes_count > 0:
+                cur.execute("""
+                    DELETE FROM terraform_demo_table
+                    WHERE id NOT IN (
+                        SELECT MIN(id) FROM terraform_demo_table GROUP BY title
+                    )
+                """)
+                deleted = cur.rowcount
+                conn.commit()
+            else:
+                deleted = 0
+
+        return {"duplicates_found": dupes_count, "deleted": deleted, "dry_run": dry_run}
+    finally:
+        conn.close()
@@ -0,0 +1 @@
+psycopg2-binary
@@ -0,0 +1,33 @@
+# 2026-03-21 — pg-delete-old: удаляет строки старше N минут (default 60).
+# Тестирует: DELETE с RETURNING, идемпотентность (повторный вызов = 0 удалений если нет старых).
+import os, psycopg2, psycopg2.extras
+
+def delete_old(event):
+    older_than_min = max(int(event.get("older_than_min", 60)), 1)
+    prefix_filter = event.get("prefix", "")
+
+    conn = psycopg2.connect(
+        host=os.environ["PGHOST"], port=int(os.environ.get("PGPORT", 5432)),
+        dbname=os.environ["PGDATABASE"], user=os.environ["PGUSER"],
+        password=os.environ["PGPASSWORD"], sslmode=os.environ.get("PGSSLMODE", "require"),
+    )
+    try:
+        with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+            if prefix_filter:
+                cur.execute(
+                    "DELETE FROM terraform_demo_table "
+                    "WHERE created_at < now() - interval '1 minute' * %s "
+                    "AND title LIKE %s RETURNING id, title",
+                    (older_than_min, f"{prefix_filter}%"),
+                )
+            else:
+                cur.execute(
+                    "DELETE FROM terraform_demo_table "
+                    "WHERE created_at < now() - interval '1 minute' * %s RETURNING id, title",
+                    (older_than_min,),
+                )
+            deleted = [dict(r) for r in cur.fetchall()]
+        conn.commit()
+        return {"deleted": len(deleted), "older_than_min": older_than_min, "sample": deleted[:5]}
+    finally:
+        conn.close()
@@ -0,0 +1 @@
+psycopg2-binary
@@ -0,0 +1,36 @@
+# 2026-03-21 — pg-search: полнотекстовый поиск по title через ILIKE + LIMIT/OFFSET.
+# Тестирует: пагинацию, спецсимволы в input (XSS, SQL injection attempt → безопасно через параметры).
+import os, psycopg2, psycopg2.extras
+
+def search(event):
+    # «query» — основной параметр (user-friendly), «q» — алиас для совместимости.
+    query = str(event.get("query") or event.get("q") or "")[:200]
+    # int() может упасть если юзер прислал строку — защищаем try/except.
+    try:
+        limit = max(1, min(int(event.get("limit", 20)), 100))
+    except (TypeError, ValueError):
+        limit = 20
+    try:
+        offset = max(0, int(event.get("offset", 0)))
+    except (TypeError, ValueError):
+        offset = 0
+
+    conn = psycopg2.connect(
+        host=os.environ["PGHOST"], port=int(os.environ.get("PGPORT", 5432)),
+        dbname=os.environ["PGDATABASE"], user=os.environ["PGUSER"],
+        password=os.environ["PGPASSWORD"], sslmode=os.environ.get("PGSSLMODE", "require"),
+    )
+    try:
+        with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+            pattern = f"%{query}%" if query else "%"
+            cur.execute(
+                "SELECT id, title, created_at::text FROM terraform_demo_table "
+                "WHERE title ILIKE %s ORDER BY id DESC LIMIT %s OFFSET %s",
+                (pattern, limit, offset),
+            )
+            rows = [dict(r) for r in cur.fetchall()]
+            cur.execute("SELECT COUNT(*) FROM terraform_demo_table WHERE title ILIKE %s", (pattern,))
+            total = cur.fetchone()["count"]
+        return {"rows": rows, "count": len(rows), "total": total, "q": query, "limit": limit, "offset": offset}
+    finally:
+        conn.close()
@@ -0,0 +1 @@
+psycopg2-binary
@@ -0,0 +1,36 @@
+# 2026-03-21 — pg-upsert: INSERT ... ON CONFLICT (title) DO UPDATE.
+# Тестирует: идемпотентность вставки — один и тот же title можно вызывать 100 раз подряд.
+# Требует уникального индекса на title — создаётся при первом вызове (CREATE UNIQUE INDEX IF NOT EXISTS).
+import os, psycopg2
+
+def upsert(event):
+    title = str(event.get("title", "upsert-default"))[:255]
+    payload = str(event.get("payload", ""))[:500]
+
+    conn = psycopg2.connect(
+        host=os.environ["PGHOST"], port=int(os.environ.get("PGPORT", 5432)),
+        dbname=os.environ["PGDATABASE"], user=os.environ["PGUSER"],
+        password=os.environ["PGPASSWORD"], sslmode=os.environ.get("PGSSLMODE", "require"),
+    )
+    try:
+        with conn.cursor() as cur:
+            # Создаём уникальный индекс если нет — для поддержки ON CONFLICT
+            cur.execute(
+                "CREATE UNIQUE INDEX IF NOT EXISTS terraform_demo_table_title_uniq "
+                "ON terraform_demo_table (title)"
+            )
+            cur.execute(
+                "INSERT INTO terraform_demo_table (title) VALUES (%s) "
+                "ON CONFLICT (title) DO UPDATE SET created_at = now() "
+                "RETURNING id, title, created_at::text, xmax",
+                (title,),
+            )
+            row = cur.fetchone()
+            was_insert = row[3] == 0   # xmax=0 означает INSERT, иначе UPDATE
+        conn.commit()
+        return {
+            "id": row[0], "title": row[1], "created_at": row[2],
+            "action": "inserted" if was_insert else "updated",
+        }
+    finally:
+        conn.close()
@@ -0,0 +1 @@
+psycopg2-binary
@@ -0,0 +1,54 @@
+# 2026-03-21 — py-retry-writer: пишет N строк с retry при PG ошибке.
+# Тестирует: устойчивость к transient PG errors (simulate_error=true), retry logic,
+# корректный rollback при частичном сбое.
+import os, time, psycopg2, random
+
+_MAX_RETRIES = 3
+
+def retry_write(event):
+    n = min(int(event.get("n", 5)), 100)
+    prefix = str(event.get("prefix", "retry"))[:40]
+    # simulate_error: с вероятностью 30% кидает OperationalError на 2-й попытке
+    simulate = str(event.get("simulate_error", "false")).lower() in ("true", "1")
+
+    attempt = 0
+    last_err = None
+
+    while attempt < _MAX_RETRIES:
+        attempt += 1
+        try:
+            conn = psycopg2.connect(
+                host=os.environ["PGHOST"], port=int(os.environ.get("PGPORT", 5432)),
+                dbname=os.environ["PGDATABASE"], user=os.environ["PGUSER"],
+                password=os.environ["PGPASSWORD"], sslmode=os.environ.get("PGSSLMODE", "require"),
+            )
+            inserted = []
+            try:
+                with conn.cursor() as cur:
+                    for i in range(n):
+                        # Симуляция: на первой попытке падаем с вероятностью 50%
+                        if simulate and attempt == 1 and i == n // 2:
+                            raise psycopg2.OperationalError("simulated transient error")
+                        title = f"{prefix}-{int(time.time()*1000)}-{i}-a{attempt}"
+                        cur.execute(
+                            "INSERT INTO terraform_demo_table (title) VALUES (%s) RETURNING id",
+                            (title,),
+                        )
+                        inserted.append(cur.fetchone()[0])
+                conn.commit()
+                return {
+                    "ok": True, "inserted": len(inserted),
+                    "attempts": attempt, "first_id": inserted[0] if inserted else None,
+                }
+            except Exception as e:
+                conn.rollback()
+                raise
+            finally:
+                conn.close()
+        except psycopg2.OperationalError as e:
+            last_err = str(e)
+            if attempt < _MAX_RETRIES:
+                time.sleep(0.3 * attempt)   # exponential backoff
+            continue
+
+    return {"ok": False, "attempts": attempt, "last_error": last_err}
@@ -0,0 +1 @@
+psycopg2-binary
@@ -0,0 +1,3 @@
+# 2026-03-17 00:00
+# requirements.txt — зависимости для функции запуска SQL.
+psycopg2-binary==2.9.9
@@ -0,0 +1,39 @@
+# 2026-03-17 00:00
+# sql_runner.py — функция для выполнения SQL-операторов из входного события.
+import os
+import psycopg2
+
+
+def run_sql(event):
+    # Выполняет список SQL-операторов в одной транзакции для атомарной инициализации схемы.
+    # Параметры подключения передаются раздельно, чтобы избежать ошибок парсинга DSN при спецсимволах.
+    pg_host = os.environ["PGHOST"]
+    pg_port = os.environ.get("PGPORT", "5432")
+    pg_database = os.environ["PGDATABASE"]
+    pg_user = os.environ["PGUSER"]
+    pg_password = os.environ["PGPASSWORD"]
+    pg_sslmode = os.environ.get("PGSSLMODE", "require")
+    statements = event.get("statements", [])
+
+    if not statements:
+        return {"error": "no statements provided"}
+
+    connection = psycopg2.connect(
+        host=pg_host,
+        port=pg_port,
+        dbname=pg_database,
+        user=pg_user,
+        password=pg_password,
+        sslmode=pg_sslmode,
+    )
+    try:
+        cursor = connection.cursor()
+        for statement in statements:
+            cursor.execute(statement)
+        connection.commit()
+        return {"ok": True, "executed": len(statements)}
+    except Exception as error:
+        connection.rollback()
+        return {"error": str(error)}
+    finally:
+        connection.close()
@@ -0,0 +1,20 @@
+# 2026-03-19
+# stress_bigloop.py — CPU-интенсивная функция: считает сумму квадратов N чисел.
+# Проверяет поведение под нагрузкой (большая и средняя итерация).
+
+import time
+
+_VERSION = "v1"
+
+
+def run(event):
+    n = int(event.get("n", 500_000))
+    start = time.monotonic()
+    total = sum(i * i for i in range(n))
+    elapsed = round(time.monotonic() - start, 4)
+    return {
+        "version": _VERSION,
+        "n": n,
+        "sum_of_squares": total,
+        "elapsed_sec": elapsed,
+    }
@@ -0,0 +1,13 @@
+# 2026-03-19
+# stress_divzero.py — намеренно делит на ноль (ZeroDivisionError).
+# Проверяет: платформа перехватывает панику, возвращает HTTP 500, не роняет под.
+
+_VERSION = "v1"
+
+
+def run(event):
+    numerator = int(event.get("n", 42))
+    denominator = int(event.get("d", 0))  # по умолчанию 0 — намеренный краш
+    # ZeroDivisionError: проверяем что платформа обрабатывает исключения
+    result = numerator / denominator
+    return {"version": _VERSION, "result": result}
@@ -0,0 +1,7 @@
+{
+  "name": "stress-js-async",
+  "version": "1.0.0",
+  "dependencies": {
+    "pg": "^8.11.0"
+  }
+}
@@ -0,0 +1,37 @@
+// 2026-03-19
+// stress_js_async.js — делает 3 параллельных запроса к PG через Promise.all.
+// Проверяет nodejs20 runtime под умеренной нагрузкой и async/await.
+//
+// Entrypoint: stress_js_async.run
+
+'use strict';
+
+const { Client } = require('pg');
+
+exports.run = async (event) => {
+    const client = new Client({
+        host: process.env.PGHOST,
+        port: parseInt(process.env.PGPORT || '5432'),
+        database: process.env.PGDATABASE,
+        user: process.env.PGUSER,
+        password: process.env.PGPASSWORD,
+        ssl: process.env.PGSSLMODE === 'require' ? { rejectUnauthorized: false } : false,
+    });
+    await client.connect();
+    try {
+        const [ver, cnt, max] = await Promise.all([
+            client.query('SELECT version() AS v'),
+            client.query('SELECT COUNT(*) AS cnt FROM terraform_demo_table'),
+            client.query('SELECT MAX(id) AS max_id FROM terraform_demo_table'),
+        ]);
+        return {
+            runtime: 'nodejs20',
+            version: 'v1',
+            pg_version: ver.rows[0].v.split(' ').slice(0, 2).join(' '),
+            total_rows: parseInt(cnt.rows[0].cnt, 10),
+            max_id: max.rows[0].max_id,
+        };
+    } finally {
+        await client.end();
+    }
+};
@@ -0,0 +1,5 @@
+{
+  "name": "stress-js-badenv",
+  "version": "1.0.0",
+  "dependencies": {}
+}
@@ -0,0 +1,17 @@
+// 2026-03-19
+// stress_js_badenv.js — читает несуществующую переменную env и падает.
+// Проверяет: платформа перехватывает TypeError/undefined, возвращает 500.
+//
+// Entrypoint: stress_js_badenv.run
+
+'use strict';
+
+exports.run = async (event) => {
+    const crash = event.crash !== false; // по умолчанию crash=true
+    if (crash) {
+        // Читаем несуществующий env, пытаемся вызвать .toUpperCase() на undefined
+        const val = process.env.THIS_VAR_DOES_NOT_EXIST_AT_ALL;
+        return { shout: val.toUpperCase() }; // TypeError: Cannot read properties of undefined
+    }
+    return { runtime: 'nodejs20', version: 'v1', crashed: false };
+};
@@ -0,0 +1,18 @@
+# 2026-03-19
+# stress_slow.py — долгая функция: спит N секунд (по умолчанию 8).
+# Проверяет что timeout-механизм и параллельные запросы не блокируют друг друга.
+
+import time
+import os
+
+_VERSION = "v1"
+
+
+def run(event):
+    secs = int(event.get("sleep", 8))
+    time.sleep(secs)
+    return {
+        "version": _VERSION,
+        "slept_sec": secs,
+        "pid": os.getpid(),
+    }
@@ -0,0 +1 @@
+psycopg2-binary==2.9.9
@@ -0,0 +1,39 @@
+# 2026-03-19
+# stress_writer.py — пишет N строк в terraform_demo_table (по умолчанию 5).
+# Проверяет параллельные INSERT'ы и устойчивость соединения с PG при нагрузке.
+
+import os
+import psycopg2
+import time
+
+_VERSION = "v1"
+
+
+def run(event):
+    n = int(event.get("rows", 5))
+    prefix = event.get("prefix", "stress")
+
+    conn = psycopg2.connect(
+        host=os.environ["PGHOST"],
+        port=int(os.environ.get("PGPORT", "5432")),
+        dbname=os.environ["PGDATABASE"],
+        user=os.environ["PGUSER"],
+        password=os.environ["PGPASSWORD"],
+        sslmode=os.environ.get("PGSSLMODE", "require"),
+    )
+    inserted = []
+    try:
+        with conn.cursor() as cur:
+            for i in range(n):
+                title = f"{prefix}-{int(time.time()*1000)}-{i}"
+                cur.execute(
+                    "INSERT INTO terraform_demo_table (title) VALUES (%s) RETURNING id",
+                    (title,),
+                )
+                row = cur.fetchone()
+                inserted.append({"id": row[0], "title": title})
+        conn.commit()
+    finally:
+        conn.close()
+
+    return {"version": _VERSION, "inserted": inserted, "count": len(inserted)}
@@ -0,0 +1 @@
+psycopg2-binary==2.9.9
@@ -0,0 +1,133 @@
+# 2026-03-19 — добавлен version и hostname в ответ list_rows для тестирования обновления кода
+# table_rw.py — чтение и запись строк в terraform_demo_table.
+# Два entrypoint в одном файле: list_rows (JSON API) и add_row (HTML-страница + POST-обработчик).
+# ENV: PGHOST, PGPORT, PGDATABASE, PGUSER, PGPASSWORD, PGSSLMODE
+
+import os
+import json
+import socket
+import psycopg2
+import psycopg2.extras
+
+_CODE_VERSION = "v2-with-hostname"
+
+
+def _connect():
+    return psycopg2.connect(
+        host=os.environ["PGHOST"],
+        port=os.environ.get("PGPORT", "5432"),
+        dbname=os.environ["PGDATABASE"],
+        user=os.environ["PGUSER"],
+        password=os.environ["PGPASSWORD"],
+        sslmode=os.environ.get("PGSSLMODE", "require"),
+    )
+
+
+def list_rows(event):
+    # Возвращает все строки terraform_demo_table, отсортированные по убыванию created_at.
+    conn = _connect()
+    try:
+        cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
+        cur.execute(
+            "SELECT id, title, created_at::text FROM terraform_demo_table ORDER BY created_at DESC"
+        )
+        rows = [dict(r) for r in cur.fetchall()]
+        return {"rows": rows, "count": len(rows), "version": _CODE_VERSION, "host": socket.gethostname()}
+    finally:
+        conn.close()
+
+
+def _render_page(rows, message=""):
+    # HTML-страница с формой ввода и таблицей строк.
+    # message — статус последней операции (успех / ошибка).
+    rows_html = "".join(
+        f"<tr><td>{r['id']}</td><td>{r['title']}</td><td>{r['created_at']}</td></tr>"
+        for r in rows
+    )
+    msg_html = f'<p class="msg">{message}</p>' if message else ""
+    return f"""<!DOCTYPE html>
+<html lang="ru">
+<head>
+  <meta charset="utf-8">
+  <title>pg-table-writer</title>
+  <style>
+    body {{ font-family: sans-serif; max-width: 700px; margin: 40px auto; background: #111; color: #eee; }}
+    h1 {{ color: #7dd3fc; }}
+    form {{ display: flex; gap: 8px; margin-bottom: 24px; }}
+    input[type=text] {{ flex: 1; padding: 8px 12px; border-radius: 6px; border: 1px solid #444; background: #1e1e1e; color: #eee; font-size: 15px; }}
+    button {{ padding: 8px 18px; background: #2563eb; color: #fff; border: none; border-radius: 6px; cursor: pointer; font-size: 15px; }}
+    button:hover {{ background: #1d4ed8; }}
+    table {{ width: 100%; border-collapse: collapse; }}
+    th, td {{ padding: 8px 10px; border-bottom: 1px solid #333; text-align: left; }}
+    th {{ color: #7dd3fc; }}
+    .msg {{ color: #4ade80; margin-bottom: 12px; }}
+  </style>
+</head>
+<body>
+  <h1>pg-table-writer</h1>
+  <form method="POST">
+    <input type="text" name="title" placeholder="Введите строку..." autofocus required>
+    <button type="submit">Добавить</button>
+  </form>
+  {msg_html}
+  <table>
+    <thead><tr><th>#</th><th>title</th><th>created_at</th></tr></thead>
+    <tbody>{rows_html}</tbody>
+  </table>
+</body>
+</html>"""
+
+
+def add_row(event):
+    # GET  → HTML-страница с формой и списком строк.
+    # POST → вставляет строку из form-поля title или JSON-поля title,
+    #        затем возвращает обновлённую HTML-страницу.
+    # POST с Content-Type: application/json (curl/API) → возвращает JSON.
+    method = event.get("_method", "GET")
+
+    if method == "GET":
+        conn = _connect()
+        try:
+            cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
+            cur.execute("SELECT id, title, created_at::text FROM terraform_demo_table ORDER BY created_at DESC")
+            rows = [dict(r) for r in cur.fetchall()]
+        finally:
+            conn.close()
+        return _render_page(rows)
+
+    # POST — вставка строки
+    # Поле title приходит либо из JSON-тела, либо из application/x-www-form-urlencoded.
+    # Сервер уже распарсил JSON в event; form-данные приходят как event["body"] = "title=...".
+    title = event.get("title", "").strip()
+    if not title:
+        # Попытка распарсить form-encoded body (браузерная форма)
+        body = event.get("body", "")
+        if body.startswith("title="):
+            from urllib.parse import unquote_plus
+            title = unquote_plus(body[len("title="):].split("&")[0]).strip()
+
+    if not title:
+        return {"ok": False, "error": "title is required"}
+
+    conn = _connect()
+    try:
+        cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
+        cur.execute(
+            "INSERT INTO terraform_demo_table (title) VALUES (%s) RETURNING id, title, created_at::text",
+            (title,),
+        )
+        row = dict(cur.fetchone())
+        conn.commit()
+
+        # Если запрос из браузера (form POST) — возвращаем обновлённую страницу.
+        # Если из curl/API — возвращаем JSON.
+        accept = event.get("_accept", "")
+        if "application/json" in accept:
+            return {"ok": True, "row": row}
+
+        # Перечитываем все строки для обновлённой страницы
+        cur.execute("SELECT id, title, created_at::text FROM terraform_demo_table ORDER BY created_at DESC")
+        rows = [dict(r) for r in cur.fetchall()]
+        return _render_page(rows, message=f"Добавлено: «{row['title']}»")
+    finally:
+        conn.close()
@@ -0,0 +1,105 @@
+// 2026-03-20 (merge: sless_function + старый sless_job объединены в один self-contained sless_job)
+// Теперь sless_job несёт в себе runtime/entrypoint/source_dir — не нужен отдельный sless_function.
+// WaitJobDone таймаут 900s покрывает kaniko сборку (~5 мин) + выполнение SQL (~несколько сек).
+
+# Одноразовый запуск: собирает образ через kaniko, выполняет SQL, завершается.
+# Заменяет sless_function.postgres_sql_runner_create_table + sless_job.postgres_table_init_job.
+resource "sless_job" "postgres_table_init_job" {
+  name             = "pg-create-table-job-main-v13"
+  runtime          = "python3.11"
+  entrypoint       = "sql_runner.run_sql"
+  memory_mb        = 128
+  timeout_sec      = 30
+  source_dir       = "${path.module}/code/sql-runner"
+  wait_timeout_sec = 900
+  run_id           = 13
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  event_json = jsonencode({
+    statements = [
+      "CREATE TABLE IF NOT EXISTS terraform_demo_table (id serial PRIMARY KEY, title text NOT NULL, created_at timestamp DEFAULT now())"
+    ]
+  })
+
+  depends_on = [nubes_postgres_database.db]
+}
+
+# Long-running сервис на NodeJS: возвращает версию PG-сервера и счётчик строк в таблице.
+resource "sless_service" "pg_info" {
+  name        = "pg-info"
+  runtime     = "nodejs20"
+  entrypoint  = "pg_info.info"
+  memory_mb   = 128
+  timeout_sec = 15
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  source_dir = "${path.module}/code/pg-info"
+
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+resource "sless_service" "postgres_table_reader" {
+  name        = "pg-table-reader"
+  runtime     = "python3.11"
+  entrypoint  = "table_rw.list_rows"
+  memory_mb   = 128
+  timeout_sec = 30
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  source_dir = "${path.module}/code/table-rw"
+
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+output "table_reader_url" {
+  value = sless_service.postgres_table_reader.url
+}
+
+resource "sless_service" "postgres_table_writer" {
+  name        = "pg-table-writer"
+  runtime     = "python3.11"
+  entrypoint  = "table_rw.add_row"
+  memory_mb   = 256
+  timeout_sec = 45
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  source_dir = "${path.module}/code/table-rw"
+
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+output "table_writer_url" {
+  value = sless_service.postgres_table_writer.url
+}
@@ -0,0 +1,119 @@
+// 2026-03-21 — stress.tf: все стресс-сервисы для комплексного тестирования.
+// Два рантайма: nodejs20 (2), python3.11 (5).
+// Все depends_on = [sless_job.postgres_table_init_job] — таблица должна существовать.
+
+
+# ── Node.js 20 ────────────────────────────────────────────────────────────────
+
+# 3 параллельных PG-запроса через Promise.all. Проверяет async/await + nodejs20.
+resource "sless_service" "stress_js_async" {
+  name        = "stress-js-async"
+  runtime     = "nodejs20"
+  entrypoint  = "stress_js_async.run"
+  memory_mb   = 128
+  timeout_sec = 20
+  source_dir  = "${path.module}/code/stress-js-async"
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# TypeError через undefined.toUpperCase(). Без PG. Проверяет перехват JS-ошибок.
+resource "sless_service" "stress_js_badenv" {
+  name        = "stress-js-badenv"
+  runtime     = "nodejs20"
+  entrypoint  = "stress_js_badenv.run"
+  memory_mb   = 128
+  timeout_sec = 10
+  source_dir  = "${path.module}/code/stress-js-badenv"
+
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# ── Python 3.11 ───────────────────────────────────────────────────────────────
+
+# Спит N секунд. Без PG. Проверяет timeout и сосуществование долгих запросов.
+resource "sless_service" "stress_slow" {
+  name        = "stress-slow"
+  runtime     = "python3.11"
+  entrypoint  = "stress_slow.run"
+  memory_mb   = 128
+  timeout_sec = 35
+  source_dir  = "${path.module}/code/stress-slow"
+
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# CPU-нагрузка: сумма квадратов N чисел. Без PG. Проверяет compute-bound задачи.
+resource "sless_service" "stress_bigloop" {
+  name        = "stress-bigloop"
+  runtime     = "python3.11"
+  entrypoint  = "stress_bigloop.run"
+  memory_mb   = 256
+  timeout_sec = 60
+  source_dir  = "${path.module}/code/stress-bigloop"
+
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# ZeroDivisionError. Без PG. Проверяет перехват Python-исключений → HTTP 500.
+resource "sless_service" "stress_divzero" {
+  name        = "stress-divzero"
+  runtime     = "python3.11"
+  entrypoint  = "stress_divzero.run"
+  memory_mb   = 128
+  timeout_sec = 10
+  source_dir  = "${path.module}/code/stress-divzero"
+
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# Параллельный INSERT в terraform_demo_table через psycopg2. Проверяет PG-write.
+resource "sless_service" "stress_writer" {
+  name        = "stress-writer"
+  runtime     = "python3.11"
+  entrypoint  = "stress_writer.run"
+  memory_mb   = 128
+  timeout_sec = 60
+  source_dir  = "${path.module}/code/stress-writer"
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  depends_on = [sless_job.postgres_table_init_job]
+}
+
+# Агрегированная статистика terraform_demo_table (COUNT/MIN/MAX). Для мониторинга.
+resource "sless_service" "pg_stats" {
+  name        = "pg-stats"
+  runtime     = "python3.11"
+  entrypoint  = "pg_stats.get_stats"
+  memory_mb   = 128
+  timeout_sec = 15
+  source_dir  = "${path.module}/code/pg-stats"
+
+  env_vars = {
+    PGHOST     = local.pg_host
+    PGPORT     = "5432"
+    PGDATABASE = local.pg_database
+    PGUSER     = local.pg_username
+    PGPASSWORD = local.pg_password
+    PGSSLMODE  = "require"
+  }
+
+  depends_on = [sless_job.postgres_table_init_job]
+}
@@ -1,176 +0,0 @@
-#!/bin/bash
-# test_cache_matrix.sh — 2026-03-23 (v4)
-# Комплексный тест кэша registry:
-#   Phase 1 — полный деплой всех 24 ресурсов (kaniko builds, т.к. нет образов)
-#   Phase 2 — destroy sless_* + re-apply (все образы из кэша)
-#   Phase 3 — одновременно: удаление 2, смена кода 2, смена параметров 2
-# ВАЖНО: postgres.tf НЕ переименовывается и НЕ трогается никогда.
-# Destroy sless-ресурсов делается путём переименования tf-файлов в .tf.bak,
-# затем terraform apply (видит что ресурсов нет → удаляет их из state+кластера),
-# затем файлы возвращаются обратно. Никаких -target.
-
-set -euo pipefail
-DIR="$(cd "$(dirname "$0")" && pwd)"
-LOG="$DIR/test_cache_matrix_$(date +%Y%m%d_%H%M%S).log"
-TIMINGS="$LOG.timings"
-PASS=0
-FAIL=0
-
-log() { echo "[$(date +%H:%M:%S)] $*" | tee -a "$LOG"; }
-sep() { log "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"; }
-
-timed_op() {
-  local label="$1"; shift
-  log "▶ START: $label"
-  local t0; t0=$(date +%s%3N)
-  "$@" 2>&1 | tee -a "$LOG"
-  local rc=${PIPESTATUS[0]}
-  local t1; t1=$(date +%s%3N)
-  local elapsed=$(( (t1 - t0) / 1000 ))
-  if [[ $rc -eq 0 ]]; then
-    log "✓ DONE: $label — ${elapsed}s"
-    PASS=$((PASS+1))
-  else
-    log "✗ FAIL: $label — ${elapsed}s (exit $rc)"
-    FAIL=$((FAIL+1))
-  fi
-  echo "$label: ${elapsed}s" >> "$TIMINGS"
-  return $rc
-}
-
-destroy_sless_only() {
-  # Переименовываем tf-файлы с sless-ресурсами в .tf.bak → terraform apply их удалит.
-  # Никаких -target — чтобы не затрагивать postgres и не получать state drift.
-  local label="$1"
-  local SLESS_FILES=("chaos_marathon.tf" "functions.tf" "stress.tf")
-
-  local has_state
-  has_state=$(terraform state list 2>/dev/null | grep -cE '^(sless_service|sless_job)' || true)
-  if [[ "$has_state" -eq 0 ]]; then
-    log "  (nothing to destroy for $label — state empty)"
-    return 0
-  fi
-  log "  Hiding sless tf-files → apply will destroy $has_state resources"
-
-  for f in "${SLESS_FILES[@]}"; do
-    [[ -f "$DIR/$f" ]] && mv "$DIR/$f" "$DIR/$f.bak"
-  done
-
-  timed_op "$label" terraform apply -auto-approve
-
-  for f in "${SLESS_FILES[@]}"; do
-    [[ -f "$DIR/$f.bak" ]] && mv "$DIR/$f.bak" "$DIR/$f"
-  done
-  log "  sless tf-files restored"
-}
-
-cd "$DIR"
-
-sep
-log "PHASE 1: Полный начальный деплой"
-sep
-destroy_sless_only "phase1-pre-clean"
-timed_op "phase1-apply-all" terraform apply -auto-approve
-
-log "--- Образы в registry после Phase 1 ---"
-kubectl exec -n sless deployment/sless-registry -- sh -c   'find /var/lib/registry -name "*.json" -path "*/tags/*" 2>/dev/null | sed "s|.*repository/||;s|/_manifests.*||" | sort | uniq -c | sort -rn'   2>/dev/null | head -30 | tee -a "$LOG" || log "(registry inspect failed)"
-
-sep
-log "PHASE 2: Destroy sless_* → Re-apply (ожидаем cache hits)"
-sep
-destroy_sless_only "phase2-destroy"
-timed_op "phase2-apply-cached" terraform apply -auto-approve
-
-sep
-log "PHASE 3: Mixed ops (delete+code+params)"
-sep
-
-log "--- 3a: destroy stress_divzero, chaos_echo (comment out → apply → restore) ---"
-python3 - <<'PYEOF'
-import re, pathlib
-
-def comment_out_resource(path, resource_type, resource_name):
-    text = pathlib.Path(path).read_text()
-    # Находим блок resource "type" "name" { ... } и оборачиваем в /* */
-    pattern = rf'(resource\s+"{re.escape(resource_type)}"\s+"{re.escape(resource_name)}"\s*\{{)'
-    match = re.search(pattern, text)
-    if not match:
-        print(f"  WARNING: {resource_type}.{resource_name} not found in {path}")
-        return
-    # Найти закрывающую скобку блока
-    start = match.start()
-    depth = 0
-    i = match.start()
-    while i < len(text):
-        if text[i] == '{': depth += 1
-        elif text[i] == '}':
-            depth -= 1
-            if depth == 0:
-                end = i + 1
-                break
-        i += 1
-    block = text[start:end]
-    commented = "/* COMMENTED_OUT_FOR_TEST\n" + block + "\nCOMMENTED_OUT_FOR_TEST */"
-    pathlib.Path(path).write_text(text[:start] + commented + text[end:])
-    print(f"  commented out: {resource_type}.{resource_name} in {path}")
-
-comment_out_resource("stress.tf", "sless_service", "stress_divzero")
-comment_out_resource("chaos_marathon.tf", "sless_service", "chaos_echo")
-PYEOF
-timed_op "phase3a-destroy-2" terraform apply -auto-approve
-# Восстанавливаем закомментированные блоки
-python3 - <<'PYEOF'
-import pathlib, re
-
-for fname in ("stress.tf", "chaos_marathon.tf"):
-    p = pathlib.Path(fname)
-    text = p.read_text()
-    text = re.sub(r'/\* COMMENTED_OUT_FOR_TEST\n', '', text)
-    text = re.sub(r'\nCOMMENTED_OUT_FOR_TEST \*/', '', text)
-    p.write_text(text)
-    print(f"  restored: {fname}")
-PYEOF
-log "  stress_divzero, chaos_echo removed from state and k8s"
-
-log "--- 3b: code changes (new sha256 → kaniko) ---"
-echo "" >> "$DIR/code/pg-counter/pg_counter.py"
-echo "# cache-test-$(date +%s)" >> "$DIR/code/pg-counter/pg_counter.py"
-echo "" >> "$DIR/code/stress-js-async/stress_js_async.js"
-echo "// cache-test-$(date +%s)" >> "$DIR/code/stress-js-async/stress_js_async.js"
-log "  changed: pg_counter.py, stress_js_async.js"
-
-log "--- 3c: param changes (same sha256 → no kaniko) ---"
-python3 - <<'PYEOF'
-import re, sys
-with open("stress.tf") as f:
-    content = f.read()
-orig = content
-content = re.sub(
-    r'(resource "sless_service" "stress_slow" \{[^}]*?)memory_mb\s*=\s*\d+',
-    lambda m: m.group(1) + 'memory_mb   = 192',
-    content, flags=re.DOTALL
-)
-content = re.sub(
-    r'(resource "sless_service" "pg_stats" \{[^}]*?)timeout_sec\s*=\s*\d+',
-    lambda m: m.group(1) + 'timeout_sec = 20',
-    content, flags=re.DOTALL
-)
-if content == orig:
-    print("  stress.tf: no changes (already patched?)", file=sys.stderr)
-else:
-    with open("stress.tf", "w") as f:
-        f.write(content)
-    print("  stress.tf: stress_slow→memory_mb=192, pg_stats→timeout_sec=20")
-PYEOF
-
-log "--- 3d: apply всех mixed изменений ---"
-log "  Expected: stress_divzero+chaos_echo=cache_hit, pg_counter+stress_js_async=kaniko, stress_slow+pg_stats=k8s_only"
-timed_op "phase3d-mixed-apply" terraform apply -auto-approve
-
-sep
-log "ИТОГ"
-sep
-log "Timings:"
-cat "$TIMINGS" 2>/dev/null | tee -a "$LOG"
-log "Pass: $PASS | Fail: $FAIL"
-log "Лог: $LOG"
@@ -1,6 +1,5 @@
 // Изменено: 2026-03-20 (merge: FunctionJob теперь самодостаточен — убран FunctionRef, добавлены Runtime/Entrypoint/Env)
 // Изменено: 2026-03-21 (fix: DeleteJob возвращает 404 вместо 204 при отсутствующем объекте)
-// Изменено: 2026-03-22 (fix: UploadJobCode retry loop против cache lag controller-runtime)
 // jobs.go — CRUD handlers для FunctionJob CRD.
 // Создаёт/читает/удаляет k8s FunctionJob ресурсы.
 // Namespace берётся из URL: /v1/namespaces/{namespace}/jobs/{name}
@@ -8,9 +7,7 @@
 package handler

 import (
-	"crypto/sha256"
 	"encoding/json"
-	"fmt"
 	"io"
 	"net/http"
 	"time"
@@ -188,24 +185,14 @@ func (h *Handler) UploadJobCode(w http.ResponseWriter, r *http.Request) {
 	ns := namespace(r)
 	name := pathVar(r, "name")

-	// Читаем FunctionJob для получения runtime.
-	// Retry до 5 раз с задержкой 200мс — защита от cache lag controller-runtime:
-	// сразу после POST /jobs (201) informer cache может ещё не синхронизировать новый CR.
+	// Читаем FunctionJob для получения runtime
 	fj := &slessv1alpha1.FunctionJob{}
-	var getJobErr error
-	for i := 0; i < 5; i++ {
-		getJobErr = h.K8s.Get(r.Context(), client.ObjectKey{Name: name, Namespace: ns}, fj)
-		if getJobErr == nil || !errors.IsNotFound(getJobErr) {
-			break
-		}
-		time.Sleep(200 * time.Millisecond)
-	}
-	if getJobErr != nil {
-		if errors.IsNotFound(getJobErr) {
+	if err := h.K8s.Get(r.Context(), client.ObjectKey{Name: name, Namespace: ns}, fj); err != nil {
+		if errors.IsNotFound(err) {
 			writeJSON(w, http.StatusNotFound, errResp("job not found"))
 			return
 		}
-		writeJSON(w, http.StatusInternalServerError, errResp(getJobErr.Error()))
+		writeJSON(w, http.StatusInternalServerError, errResp(err.Error()))
 		return
 	}

@@ -234,10 +221,8 @@ func (h *Handler) UploadJobCode(w http.ResponseWriter, r *http.Request) {
 		return
 	}

-	// Версия = sha256(загруженный zip). Одинаковый код → одинаковый s3Key → cache hit.
-	// Изменился код → новый хеш → новый build.
-	zipHash := sha256.Sum256(zipData)
-	version := fmt.Sprintf("%x", zipHash[:])[:16]
+	// Версия на основе timestamp — каждый upload → новый уникальный ключ в S3
+	version := time.Now().Format("20060102150405")
 	s3Key, err := h.S3.UploadContext(r.Context(), ns, name, version, buf, int64(buf.Len()))
 	if err != nil {
 		writeJSON(w, http.StatusInternalServerError, errResp("upload to S3: "+err.Error()))
@@ -1,7 +1,6 @@
 // Создано: 2026-03-20 (function-service-split)
 // Изменено: 2026-03-21 (fix: DeleteService возвращает 404 вместо 204 при отсутствующем объекте)
 // Изменено: 2026-03-22 (fix: CreateService 409 при пересоздании сервиса через terraform -replace)
-// Изменено: 2026-03-23 (fix: UploadServiceCode retry при 404 из-за cache lag controller-runtime)
 // services.go — CRUD handlers для Service CRD (sless_service).
 // sless_service = long-running Deployment + URL. Каждый вызов проксируется к поду.
 // Namespace берётся из URL: /v1/namespaces/{namespace}/services/{name}
@@ -9,9 +8,7 @@
 package handler

 import (
-	"crypto/sha256"
 	"encoding/json"
-	"fmt"
 	"io"
 	"net/http"
 	"time"
@@ -353,24 +350,13 @@ func (h *Handler) UploadServiceCode(w http.ResponseWriter, r *http.Request) {
 	ns := namespace(r)
 	name := pathVar(r, "name")

-	// Retry до 5 раз с задержкой 200мс — защита от cache lag controller-runtime.
-	// Проблема: после POST /services (201) кеш informer может не успеть обновиться,
-	// и Get возвращает IsNotFound в течение ~100-400мс после создания CR.
 	svc := &slessv1alpha1.Service{}
-	var getErr error
-	for i := 0; i < 5; i++ {
-		getErr = h.K8s.Get(r.Context(), client.ObjectKey{Name: name, Namespace: ns}, svc)
-		if getErr == nil || !errors.IsNotFound(getErr) {
-			break
-		}
-		time.Sleep(200 * time.Millisecond)
-	}
-	if getErr != nil {
-		if errors.IsNotFound(getErr) {
+	if err := h.K8s.Get(r.Context(), client.ObjectKey{Name: name, Namespace: ns}, svc); err != nil {
+		if errors.IsNotFound(err) {
 			writeJSON(w, http.StatusNotFound, errResp("service not found"))
 			return
 		}
-		writeJSON(w, http.StatusInternalServerError, errResp(getErr.Error()))
+		writeJSON(w, http.StatusInternalServerError, errResp(err.Error()))
 		return
 	}

@@ -397,10 +383,7 @@ func (h *Handler) UploadServiceCode(w http.ResponseWriter, r *http.Request) {
 		return
 	}

-	// Версия = sha256(загруженный zip). Одинаковый код → одинаковый s3Key → cache hit.
-	// Изменился код → новый хеш → новый build.
-	zipHash := sha256.Sum256(zipData)
-	version := fmt.Sprintf("%x", zipHash[:])[:16]
+	version := time.Now().Format("20060102150405")
 	s3Key, err := h.S3.UploadContext(r.Context(), ns, name, version, buf, int64(buf.Len()))
 	if err != nil {
 		writeJSON(w, http.StatusInternalServerError, errResp("upload to S3: "+err.Error()))
@@ -10,10 +10,9 @@
 package handler

 import (
-	"crypto/sha256"
-	"fmt"
 	"io"
 	"net/http"
+	"time"

 	"k8s.io/apimachinery/pkg/api/errors"
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -66,10 +65,8 @@ func (h *Handler) UploadCode(w http.ResponseWriter, r *http.Request) {
 		return
 	}

-	// Версия = sha256(загруженный zip). Одинаковый код → одинаковый s3Key → cache hit.
-	// Изменился код → новый хеш → новый build.
-	zipHash := sha256.Sum256(zipData)
-	version := fmt.Sprintf("%x", zipHash[:])[:16]
+	// Версия на основе timestamp — каждый upload → новый уникальный ключ в S3
+	version := time.Now().Format("20060102150405")
 	s3Key, err := h.S3.UploadContext(r.Context(), ns, name, version, buf, int64(buf.Len()))
 	if err != nil {
 		writeJSON(w, http.StatusInternalServerError, errResp("upload to S3: "+err.Error()))
@@ -34,55 +34,47 @@ type Projecter interface {

 // Builder — управляет сборкой Docker образов через kaniko Jobs в k8s.
 type Builder struct {
-	client           client.Client
-	builderImage     string // образ kaniko
-	registryHost     string // куда пушим образ (DockerHub: "naeel"; Harbor: "host")
-	registryProject  string // проект/org внутри registry (Harbor: project; DockerHub: пусто)
-	registrySecret   string // имя k8s Secret с docker-кредами для kaniko
-	registryInsecure bool   // true = in-cluster HTTP registry, без TLS и авторизации
-	s3Endpoint       string // откуда kaniko берёт код
-	s3AccessKey      string
-	s3SecretKey      string
-	s3Bucket         string
-	namespace        string    // namespace где запускаем build Job'ы
-	harborClient     Projecter // nil если Harbor не используется
+	client          client.Client
+	builderImage    string // образ kaniko
+	registryHost    string // куда пушим образ (DockerHub: "naeel"; Harbor: "host")
+	registryProject string // проект/org внутри registry (Harbor: project; DockerHub: пусто)
+	registrySecret  string // имя k8s Secret с docker-кредами для kaniko
+	s3Endpoint      string // откуда kaniko берёт код
+	s3AccessKey     string
+	s3SecretKey     string
+	s3Bucket        string
+	namespace       string    // namespace где запускаем build Job'ы
+	harborClient    Projecter // nil если Harbor не используется
 }

 // Config — параметры для создания Builder'а.
 type Config struct {
-	BuilderImage     string
-	RegistryHost     string
-	RegistryProject  string // пусто = DockerHub-режим (2 уровня); задан = project-режим (3 уровня)
-	RegistrySecret   string // имя k8s Secret с .dockerconfigjson для пуша образов
-	RegistryInsecure bool   // true = HTTP registry (in-cluster), kaniko получает --insecure
-	S3Endpoint       string
-	S3AccessKey      string
-	S3SecretKey      string
-	S3Bucket         string
-	Namespace        string
-	HarborClient     Projecter // nil — Harbor не используется, EnsureProject пропускается
+	BuilderImage    string
+	RegistryHost    string
+	RegistryProject string // пусто = DockerHub-режим (2 уровня); задан = project-режим (3 уровня)
+	RegistrySecret  string // имя k8s Secret с .dockerconfigjson для пуша образов
+	S3Endpoint      string
+	S3AccessKey     string
+	S3SecretKey     string
+	S3Bucket        string
+	Namespace       string
+	HarborClient    Projecter // nil — Harbor не используется, EnsureProject пропускается
 }

 // New создаёт новый Builder.
 func New(c client.Client, cfg Config) *Builder {
-	// In-cluster HTTP registry не требует docker credentials — монтировать Secret не нужно.
-	registrySecret := cfg.RegistrySecret
-	if cfg.RegistryInsecure {
-		registrySecret = ""
-	}
 	return &Builder{
-		client:           c,
-		builderImage:     cfg.BuilderImage,
-		registryHost:     cfg.RegistryHost,
-		registryProject:  cfg.RegistryProject,
-		registrySecret:   registrySecret,
-		registryInsecure: cfg.RegistryInsecure,
-		s3Endpoint:       cfg.S3Endpoint,
-		s3AccessKey:      cfg.S3AccessKey,
-		s3SecretKey:      cfg.S3SecretKey,
-		s3Bucket:         cfg.S3Bucket,
-		namespace:        cfg.Namespace,
-		harborClient:     cfg.HarborClient,
+		client:          c,
+		builderImage:    cfg.BuilderImage,
+		registryHost:    cfg.RegistryHost,
+		registryProject: cfg.RegistryProject,
+		registrySecret:  cfg.RegistrySecret,
+		s3Endpoint:      cfg.S3Endpoint,
+		s3AccessKey:     cfg.S3AccessKey,
+		s3SecretKey:     cfg.S3SecretKey,
+		s3Bucket:        cfg.S3Bucket,
+		namespace:       cfg.Namespace,
+		harborClient:    cfg.HarborClient,
 	}
 }

@@ -118,94 +110,74 @@ func (b *Builder) ImageRef(namespace, funcName, s3Key string) string {
 }

 // ImageExists проверяет наличие образа в Docker Registry v2 по тегу (без pull).
-// Возвращает (true, nil) если образ есть, (false, nil) если нет,
-// (false, err) если registry недоступен — контроллер должен requeue, не запускать сборку.
+// Использует анонимный bearer-token для публичных репо (DockerHub).
+// Возвращает true если образ с таким тегом уже запушен — сборка не нужна.
 //
-// Два режима:
-//   - insecure (in-cluster registry:2): HTTP, без TLS, без авторизации
-//   - secure (DockerHub): HTTPS, анонимный bearer-token для публичных репо
-func (b *Builder) ImageExists(ctx context.Context, imageRef string) (bool, error) {
+// Почему анонимный токен, а не credentials:
+//
+//	DockerHub выдаёт pull-token без авторизации для публичных репо через
+//	GET /token?service=registry.docker.io&scope=repository:{repo}:pull
+//	Это стандартный Docker Registry v2 auth flow (RFC 7235).
+func (b *Builder) ImageExists(ctx context.Context, imageRef string) bool {
+	// imageRef вида: "naeel/slessffd1-pg-search:47cab27ada70"
+	// или "host/project/func:tag" — разбираем по последнему ":"
 	colonIdx := strings.LastIndex(imageRef, ":")
 	if colonIdx < 0 {
-		return false, nil
+		return false
 	}
 	repoFull := imageRef[:colonIdx]
 	tag := imageRef[colonIdx+1:]

-	if b.registryInsecure {
-		// In-cluster HTTP registry — без авторизации и TLS.
-		// repoFull вида "host:port/path" → берём host до первого /
-		slashIdx := strings.Index(repoFull, "/")
-		if slashIdx < 0 {
-			return false, nil
-		}
-		registryHost := repoFull[:slashIdx]
-		repo := repoFull[slashIdx+1:]
-
-		httpClient := &http.Client{Timeout: 5 * time.Second}
-		manifestURL := fmt.Sprintf("http://%s/v2/%s/manifests/%s", registryHost, repo, tag)
-		req, err := http.NewRequestWithContext(ctx, http.MethodHead, manifestURL, nil)
-		if err != nil {
-			return false, err
-		}
-		req.Header.Set("Accept", "application/vnd.docker.distribution.manifest.v2+json")
-		resp, err := httpClient.Do(req)
-		if err != nil {
-			// Registry недоступен — не притворяемся что образа нет, requeue
-			return false, fmt.Errorf("registry unavailable at %s: %w", registryHost, err)
-		}
-		defer resp.Body.Close()
-		switch resp.StatusCode {
-		case http.StatusOK:
-			return true, nil
-		case http.StatusNotFound:
-			return false, nil
-		default:
-			return false, fmt.Errorf("unexpected registry response: %d", resp.StatusCode)
-		}
-	}
-
-	// Secure registry (DockerHub или HTTPS).
-	// DockerHub: "naeel/sless-ff-pg" → registry = index.docker.io
-	// Приватный: "harbor.host/proj/func" → registry = harbor.host
+	// Определяем registry host и repo path.
+	// DockerHub: "naeel/sless-ff-pg" → registry = index.docker.io, repo = "naeel/sless-ff-pg"
+	// Приватный: "harbor.host/proj/func" → registry = "harbor.host", repo = "proj/func"
 	registryHost := "index.docker.io"
 	repo := repoFull
 	if parts := strings.SplitN(repoFull, "/", 3); len(parts) == 3 {
+		// host/project/name — кастомный registry
 		registryHost = parts[0]
 		repo = parts[1] + "/" + parts[2]
 	}

+	// Получаем анонимный/публичный bearer-token для pull доступа к репо.
+	// DockerHub: https://auth.docker.io/token?service=registry.docker.io&scope=repository:{repo}:pull
+	// Для приватных registry этот шаг вернёт 401 → ImageExists вернёт false → пойдём строить.
 	tokenURL := fmt.Sprintf("https://auth.docker.io/token?service=registry.docker.io&scope=repository:%s:pull", repo)
 	if registryHost != "index.docker.io" {
+		// Для не-DockerHub registry: пробуем без токена (Harbor с allow anon push)
+		// Если 401 — false, пусть builder разберётся.
 		tokenURL = ""
 	}

 	httpClient := &http.Client{Timeout: 5 * time.Second}
+
 	var bearerToken string
 	if tokenURL != "" {
 		req, err := http.NewRequestWithContext(ctx, http.MethodGet, tokenURL, nil)
 		if err != nil {
-			return false, nil
+			return false
 		}
 		resp, err := httpClient.Do(req)
 		if err != nil || resp.StatusCode != http.StatusOK {
-			return false, nil
+			return false
 		}
 		defer resp.Body.Close()
 		var tkResp struct {
 			Token string `json:"token"`
 		}
 		if err := json.NewDecoder(resp.Body).Decode(&tkResp); err != nil {
-			return false, nil
+			return false
 		}
 		bearerToken = tkResp.Token
 	}

+	// HEAD /v2/{repo}/manifests/{tag} — проверяем наличие тега без скачивания слоёв.
 	manifestURL := fmt.Sprintf("https://%s/v2/%s/manifests/%s", registryHost, repo, tag)
 	req, err := http.NewRequestWithContext(ctx, http.MethodHead, manifestURL, nil)
 	if err != nil {
-		return false, nil
+		return false
 	}
+	// Docker Registry v2 требует Accept header для манифестов.
 	req.Header.Set("Accept", "application/vnd.docker.distribution.manifest.v2+json")
 	if bearerToken != "" {
 		req.Header.Set("Authorization", "Bearer "+bearerToken)
@@ -213,10 +185,10 @@ func (b *Builder) ImageExists(ctx context.Context, imageRef string) (bool, error

 	resp, err := httpClient.Do(req)
 	if err != nil {
-		return false, nil
+		return false
 	}
 	defer resp.Body.Close()
-	return resp.StatusCode == http.StatusOK, nil
+	return resp.StatusCode == http.StatusOK
 }

 // Build запускает kaniko Job для сборки образа функции.
@@ -258,7 +230,11 @@ func (b *Builder) Build(ctx context.Context, namespace, funcName, s3Key string)
 						{
 							Name:  "kaniko",
 							Image: b.builderImage,
-							Args:  b.kanikoArgs(s3ContextURL, imageRef),
+							Args: []string{
+								"--context=" + s3ContextURL,
+								"--destination=" + imageRef,
+								// --no-cache не поддерживается этой версией kaniko; кэш отключён по умолчанию
+							},
 							Env: []corev1.EnvVar{
 								{Name: "AWS_ACCESS_KEY_ID", Value: b.s3AccessKey},
 								{Name: "AWS_SECRET_ACCESS_KEY", Value: b.s3SecretKey},
@@ -322,20 +298,6 @@ func (b *Builder) Cleanup(ctx context.Context, jobName string) error {
 	return b.client.Delete(ctx, job, &client.DeleteOptions{PropagationPolicy: &propagation})
 }

-// kanikoArgs строит аргументы для kaniko контейнера.
-// Добавляет --insecure если registry работает по HTTP (in-cluster).
-func (b *Builder) kanikoArgs(s3ContextURL, imageRef string) []string {
-	args := []string{
-		"--context=" + s3ContextURL,
-		"--destination=" + imageRef,
-	}
-	if b.registryInsecure {
-		// --insecure: push в HTTP registry без TLS (in-cluster registry:2)
-		args = append(args, "--insecure")
-	}
-	return args
-}
-
 // dockerConfigVolumes возвращает Volume с docker-кредами если RegistrySecret задан.
 // Ключ .dockerconfigjson монтируется как config.json — стандартное имя для kaniko.
 func (b *Builder) dockerConfigVolumes() []corev1.Volume {
@@ -93,30 +93,23 @@ func generateDockerfile(runtime string, hasRequirements bool, hasPackageJSON boo
 		// Go: multi-stage build с go.work (v0.1.3+).
 		// base-образ содержит: /app/server/ (module sless/fn/server, package main).
 		// kaniko копирует пользовательский код в /app/handler/.
-		// Модуль handler всегда переименовывается в sless/fn/handler — это позволяет server.go
-		// импортировать его по фиксированному пути без replace-директивы.
-		// Почему нет replace: Go 1.23 запрещает replace для модуля, который одновременно в workspace
-		// (use ./handler). Ошибка: "workspace module sless/fn/handler is replaced at all versions".
-		// Решение: rename module → use workspace → require без replace.
+		// Генерируем go.mod для handler если его нет (module sless/fn/handler).
+		// Генерируем go.work: use ./server + use ./handler + replace sless/fn/handler => ./handler.
+		// replace позволяет server.go импортировать sless/fn/handler независимо от имени модуля пользователя.
+		// GOFLAGS=-mod=mod: позволяет go build подтягивать зависимости из handler/go.mod через GOPROXY.
 		goModStep := ""
 		if !hasGoMod {
-			// Пользователь не предоставил go.mod — генерируем минимальный с правильным именем.
+			// Пользователь не предоставил go.mod — генерируем минимальный
 			goModStep = "RUN printf 'module sless/fn/handler\\n\\ngo 1.23\\n' > /app/handler/go.mod\n"
-		} else {
-			// Пользователь предоставил go.mod с произвольным именем модуля — переименовываем.
-			goModStep = "RUN sed -i 's/^module .*/module sless\\/fn\\/handler/' /app/handler/go.mod\n"
 		}
 		content := fmt.Sprintf(
 			"FROM %s AS builder\n"+
 				"WORKDIR /app\n"+
 				"COPY . /app/handler/\n"+
 				goModStep+
-				// go.work: workspace из двух модулей без replace-директив.
-				"RUN printf 'go 1.23\\n\\nuse ./server\\nuse ./handler\\n' > /app/go.work\n"+
-				// Патчим server/go.mod в момент kaniko-сборки — добавляем require на handler.
-				// Не меняет базовый образ (выполняется на этапе сборки пользовательского образа).
-				"RUN printf '\\nrequire sless/fn/handler v0.0.0\\n' >> /app/server/go.mod\n"+
-				"RUN CGO_ENABLED=0 go build -o /server ./server\n"+
+				"RUN printf 'go 1.23\\n\\nuse ./server\\nuse ./handler\\n\\nreplace sless/fn/handler => ./handler\\n' > /app/go.work\n"+ // server/go.mod не содержит require sless/fn/handler — Go требует явного require даже при replace в go.work.
+				// Патчим server/go.mod в момент kaniko-сборки (не меняет базовый образ).
+				"RUN printf '\\nrequire sless/fn/handler v0.0.0\\n' >> /app/server/go.mod\n"+"RUN CGO_ENABLED=0 go build -o /server ./server\n"+
 				"FROM alpine:3.20\n"+
 				"COPY --from=builder /server /server\n"+
 				"EXPOSE 8080\n"+
@@ -132,17 +125,11 @@ func generateDockerfile(runtime string, hasRequirements bool, hasPackageJSON boo
 			if hasRequirements {
 				content += "RUN pip install --no-cache-dir -r /app/function/requirements.txt\n"
 			}
-			// Проверяем синтаксис всех .py файлов на этапе сборки образа.
-			// Если в коде синтаксическая ошибка — kaniko завершится с ошибкой и фаза = Failed.
-			// Без этого шага образ собирается успешно, а под падает в CrashLoopBackOff при запуске.
-			content += "RUN python -m py_compile $(find /app/function -name '*.py')\n"
 		case "nodejs20":
 			if hasPackageJSON {
 				// cd нужен т.к. npm install читает package.json из текущей директории
 				content += "RUN cd /app/function && npm install --omit=dev\n"
 			}
-			// Проверяем синтаксис всех .js файлов через node --check.
-			content += "RUN find /app/function -name '*.js' | xargs -r node --check\n"
 		}
 		return []byte(content), nil
 	}
@@ -40,11 +40,6 @@ type Config struct {
 	// Создаётся через hack/create-registry-secret.sh
 	RegistrySecret string

-	// RegistryInsecure — использовать HTTP (без TLS) для registry.
-	// Нужно для in-cluster registry:2 где нет сертификата.
-	// Включается через REGISTRY_INSECURE=true.
-	RegistryInsecure bool
-
 	// BuilderImage — образ для сборки функций (kaniko или buildah)
 	BuilderImage string

@@ -133,11 +128,6 @@ func Load() (*Config, error) {
 		cfg.RegistrySecret = "sless-registry-auth"
 	}

-	// REGISTRY_INSECURE=true — использовать HTTP вместо HTTPS для registry (in-cluster registry:2)
-	if os.Getenv("REGISTRY_INSECURE") == "true" {
-		cfg.RegistryInsecure = true
-	}
-
 	// Опциональные параметры с дефолтами
 	if v := os.Getenv("BUILDER_IMAGE"); v != "" {
 		cfg.BuilderImage = v
@@ -131,17 +131,16 @@ func main() {
 	}

 	bldr := builder.New(mgr.GetClient(), builder.Config{
-		BuilderImage:     cfg.BuilderImage,
-		RegistryHost:     cfg.RegistryHost,
-		RegistryProject:  cfg.RegistryProject,
-		RegistrySecret:   cfg.RegistrySecret,
-		RegistryInsecure: cfg.RegistryInsecure,
-		S3Endpoint:       cfg.S3Endpoint,
-		S3AccessKey:      cfg.S3AccessKey,
-		S3SecretKey:      cfg.S3SecretKey,
-		S3Bucket:         cfg.S3Bucket,
-		Namespace:        "sless",
-		HarborClient:     harborProjecter,
+		BuilderImage:    cfg.BuilderImage,
+		RegistryHost:    cfg.RegistryHost,
+		RegistryProject: cfg.RegistryProject,
+		RegistrySecret:  cfg.RegistrySecret,
+		S3Endpoint:      cfg.S3Endpoint,
+		S3AccessKey:     cfg.S3AccessKey,
+		S3SecretKey:     cfg.S3SecretKey,
+		S3Bucket:        cfg.S3Bucket,
+		Namespace:       "sless",
+		HarborClient:    harborProjecter,
 	})

 	if err = (&controllers.FunctionReconciler{
@@ -1,4 +1,4 @@
-# Изменено: 2026-03-23 — v0.1.4: fix go.work (убран replace, добавлен sed rename модуля).
+# Изменено: 2026-03-22 — v0.1.3: server/ субдиректория + go.work для поддержки пользовательских go.mod.
 # Base builder image для Go 1.23 serverless функций.
 # Это BUILDER-образ: golang:1.23-alpine + server/ + pre-cached зависимости.
 # go mod download кеширует pgx/v5 в /root/go/pkg/mod — kaniko не скачивает их при каждой сборке.
@@ -7,16 +7,14 @@
 #   FROM naeel/sless-runtime-go1.23:v0.1.3 AS builder
 #   WORKDIR /app
 #   COPY . /app/handler/
-#   RUN [ -f /app/handler/go.mod ] && sed -i 's/^module .*/module sless\/fn\/handler/' || printf '...' > /app/handler/go.mod
-#   RUN printf 'go 1.23\n\nuse ./server\nuse ./handler\n' > /app/go.work   # БЕЗ replace!
-#   RUN printf '\nrequire sless/fn/handler v0.0.0\n' >> /app/server/go.mod
+#   RUN [ -f /app/handler/go.mod ] || printf 'module sless/fn/handler\n\ngo 1.23\n' > /app/handler/go.mod
+#   RUN printf 'go 1.23\n\nuse ./server\nuse ./handler\n\nreplace sless/fn/handler => ./handler\n' > /app/go.work
 #   RUN CGO_ENABLED=0 go build -o /server ./server
 #   FROM alpine:3.20
 #   COPY --from=builder /server /server
 #
-# Почему replace убран: Go 1.23 запрещает replace для модуля, который одновременно в workspace.
-# Ошибка: "workspace module sless/fn/handler is replaced at all versions in the go.work file".
-# Решение: handler всегда переименовывается в sless/fn/handler через sed — replace не нужен.
+# Почему server/ субдиректория: go.work + replace позволяет пользователю иметь любой go.mod
+# с любыми зависимостями. Вложенные модули (nested) поддерживаются через workspace.

 FROM golang:1.23-alpine

@@ -27,7 +27,7 @@ spec:
    spec:
      containers:
        - name: funcs
-          image: naeel/sless-funcs-service:v0.1.11
+          image: naeel/sless-funcs-service:v0.1.3
          ports:
            - containerPort: 8090
          env:
@@ -188,25 +188,15 @@
            color: #8b949e;
        }

-        .fn-url-row {
-            padding: 0 14px 9px 14px;
-            display: flex;
-            align-items: center;
-            gap: 6px;
-        }
-
-        .fn-url-row:empty {
-            display: none;
-        }
-
        .fn-url {
            font-size: 0.76rem;
            color: #58a6ff;
            text-decoration: none;
+            white-space: nowrap;
            overflow: hidden;
            text-overflow: ellipsis;
-            white-space: nowrap;
-            max-width: 100%;
+            max-width: 280px;
+            flex-shrink: 1;
        }

        .fn-url:hover {
@@ -322,197 +312,6 @@
            color: #484f58;
            font-size: 0.9rem;
        }
-
-        /* Кнопки действий на карточке функции */
-        .action-btn {
-            flex-shrink: 0;
-            padding: 3px 10px;
-            border-radius: 5px;
-            border: 1px solid #30363d;
-            cursor: pointer;
-            font-size: 0.73rem;
-            font-weight: 500;
-            background: #21262d;
-            color: #8b949e;
-            transition: background 0.1s, color 0.1s;
-        }
-        .action-btn:hover { background: #30363d; color: #c9d1d9; }
-        .action-btn.del:hover { background: #3d1a1a; border-color: #6b1a1a; color: #f85149; }
-
-        /* Кодовый редактор во встроенном режиме */
-        .edit-area {
-            width: 100%;
-            min-height: 220px;
-            background: #0d1117;
-            color: #e6edf3;
-            border: none;
-            border-top: 1px solid #30363d;
-            padding: 14px 16px;
-            font-family: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, monospace;
-            font-size: 0.78rem;
-            line-height: 1.55;
-            resize: vertical;
-            outline: none;
-            display: block;
-            box-sizing: border-box;
-        }
-        .edit-actions {
-            display: flex;
-            gap: 8px;
-            padding: 8px 14px;
-            background: #161b22;
-            border-top: 1px solid #30363d;
-        }
-        .edit-save-btn {
-            padding: 5px 16px;
-            background: #238636;
-            border: 1px solid #2ea043;
-            color: #fff;
-            border-radius: 6px;
-            cursor: pointer;
-            font-size: 0.8rem;
-        }
-        .edit-save-btn:hover { background: #2ea043; }
-        .edit-save-btn:disabled { opacity: 0.5; cursor: not-allowed; }
-        .edit-cancel-btn {
-            padding: 5px 16px;
-            background: #21262d;
-            border: 1px solid #30363d;
-            color: #c9d1d9;
-            border-radius: 6px;
-            cursor: pointer;
-            font-size: 0.8rem;
-        }
-        .edit-status {
-            font-size: 0.77rem;
-            padding: 5px 8px;
-            align-self: center;
-            color: #8b949e;
-        }
-        .edit-status.ok { color: #3fb950; }
-        .edit-status.err { color: #f85149; }
-
-        /* ---------- Модалка создания функции ---------- */
-        .modal-backdrop {
-            display: none;
-            position: fixed; inset: 0;
-            background: rgba(0,0,0,0.65);
-            z-index: 100;
-            align-items: center;
-            justify-content: center;
-        }
-        .modal-backdrop.open { display: flex; }
-        .modal {
-            background: #161b22;
-            border: 1px solid #30363d;
-            border-radius: 10px;
-            width: min(660px, 95vw);
-            max-height: 90vh;
-            overflow-y: auto;
-            padding: 24px;
-            display: flex;
-            flex-direction: column;
-            gap: 14px;
-        }
-        .modal h2 {
-            font-size: 1rem;
-            font-weight: 600;
-            color: #e6edf3;
-        }
-        .modal label {
-            font-size: 0.82rem;
-            color: #8b949e;
-            display: block;
-            margin-bottom: 4px;
-        }
-        .modal input, .modal select {
-            width: 100%;
-            background: #0d1117;
-            border: 1px solid #30363d;
-            border-radius: 6px;
-            color: #e6edf3;
-            padding: 7px 10px;
-            font-size: 0.85rem;
-            box-sizing: border-box;
-            outline: none;
-        }
-        .modal input:focus, .modal select:focus { border-color: #58a6ff; }
-        .modal-row { display: flex; gap: 12px; }
-        .modal-row > div { flex: 1; }
-        .modal-code {
-            width: 100%;
-            min-height: 200px;
-            background: #0d1117;
-            border: 1px solid #30363d;
-            border-radius: 6px;
-            color: #e6edf3;
-            padding: 10px 12px;
-            font-family: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, monospace;
-            font-size: 0.78rem;
-            line-height: 1.55;
-            resize: vertical;
-            outline: none;
-            box-sizing: border-box;
-        }
-        .modal-code:focus { border-color: #58a6ff; }
-        .modal-actions {
-            display: flex;
-            justify-content: flex-end;
-            gap: 10px;
-        }
-        .modal-create-btn {
-            padding: 7px 20px;
-            background: #238636;
-            border: 1px solid #2ea043;
-            color: #fff;
-            border-radius: 6px;
-            cursor: pointer;
-            font-size: 0.85rem;
-        }
-        .modal-create-btn:hover { background: #2ea043; }
-        .modal-create-btn:disabled { opacity: 0.5; cursor: not-allowed; }
-        .modal-cancel-btn {
-            padding: 7px 20px;
-            background: #21262d;
-            border: 1px solid #30363d;
-            color: #c9d1d9;
-            border-radius: 6px;
-            cursor: pointer;
-            font-size: 0.85rem;
-        }
-        .modal-err {
-            color: #f85149;
-            font-size: 0.8rem;
-            min-height: 18px;
-        }
-        .create-fn-btn {
-            margin-left: auto;
-            background: #238636;
-            border: 1px solid #2ea043;
-            color: #fff;
-            padding: 6px 16px;
-            border-radius: 6px;
-            cursor: pointer;
-            font-size: 0.82rem;
-            transition: background 0.1s;
-        }
-        .create-fn-btn:hover { background: #2ea043; }
-
-        /* Таймер Building */
-        .fn-timer {
-            font-size: 0.72rem;
-            color: #d29922;
-            font-family: monospace;
-            margin-left: 2px;
-            flex-shrink: 0;
-        }
-        .badge-Building {
-            animation: pulse-bld 1.4s ease-in-out infinite;
-        }
-        @keyframes pulse-bld {
-            0%, 100% { opacity: 1; }
-            50% { opacity: 0.5; }
-        }
    </style>
 </head>

@@ -522,56 +321,12 @@
        <span class="logo-slash">/</span>
        <span class="ns-badge" id="ns-label">…</span>
        <button class="refresh-btn" onclick="location.reload()">↻ обновить</button>
-        <button class="create-fn-btn" id="open-create-modal">+ Создать функцию</button>
    </header>
    <main>
        <p class="summary" id="summary"></p>
        <div id="fn-list"></div>
    </main>

-    <!-- Модалка создания новой функции -->
-    <div class="modal-backdrop" id="create-modal">
-        <div class="modal" role="dialog" aria-modal="true" aria-labelledby="modal-title">
-            <h2 id="modal-title">Создать функцию</h2>
-
-            <div>
-                <label>Runtime</label>
-                <select id="m-runtime">
-                    <option value="python3.11">Python 3.11</option>
-                    <option value="nodejs20">Node.js 20</option>
-                </select>
-            </div>
-
-            <div class="modal-row">
-                <div>
-                    <label>Имя функции (k8s name)</label>
-                    <input id="m-name" type="text" placeholder="my-hello-fn" pattern="[a-z0-9][a-z0-9\-]{0,61}[a-z0-9]">
-                </div>
-                <div>
-                    <label>Entrypoint (module.func)</label>
-                    <input id="m-entrypoint" type="text" value="handler.handler">
-                </div>
-            </div>
-
-            <div>
-                <label id="m-filename-label">Файл: <code id="m-filename-display">handler.py</code></label>
-                <textarea class="modal-code" id="m-code" spellcheck="false"></textarea>
-            </div>
-
-            <div>
-                <label><span id="m-deps-name">requirements.txt</span> <span style="color:#484f58;font-size:0.75rem">(зависимости, опционально)</span></label>
-                <textarea class="modal-code" id="m-deps" spellcheck="false" style="min-height:80px"></textarea>
-            </div>
-
-            <div class="modal-err" id="m-err"></div>
-
-            <div class="modal-actions">
-                <button class="modal-cancel-btn" id="modal-cancel">Отмена</button>
-                <button class="modal-create-btn" id="modal-submit">Создать</button>
-            </div>
-        </div>
-    </div>
-
    <script id="fndata" type="application/json">__PAGE_DATA__</script>
    <script>
        (function () {
@@ -600,8 +355,6 @@
                list.appendChild(buildCard(fns[i], byFn[fns[i].name] || []));
            }

-            // ---------- Карточки функций ----------
-
            function buildCard(fn, triggers) {
                var card = $el('div', 'fn-card');
                var hdr = $el('div', 'fn-header');
@@ -610,46 +363,40 @@

                $txt(hdr, 'span', 'fn-name', fn.name);
                $txt(hdr, 'span', 'badge badge-runtime', fn.runtime);
-                var phaseBadge = $txt(hdr, 'span', 'badge badge-' + fn.phase, fn.phase || 'Pending');
+                $txt(hdr, 'span', 'badge badge-' + fn.phase, fn.phase || 'Pending');
                if (fn.kind) {
                    var kindLabel = fn.kind === 'service' ? 'always-on' : 'job';
                    $txt(hdr, 'span', 'badge badge-kind-' + fn.kind, kindLabel);
                }

-                // Для Building/Pending — таймер секунд + автополинг до Ready/Failed
-                if (fn.phase === 'Building' || fn.phase === 'Pending') {
-                    var timerEl = $txt(hdr, 'span', 'fn-timer', '0с');
-                    startBuildPoll(phaseBadge, timerEl, fn, ns, null, function(url) {
-                        if (!fn.url) { fn.url = url; setCardUrl(url); }
-                    });
-                }
-
-                if (fn.message) $txt(hdr, 'span', 'fn-msg', fn.message);
-                hdr.appendChild($el('span', 'spacer'));
-
-                // urlRow — отдельная строка под заголовком для URL
-                var urlRow = $el('div', 'fn-url-row');
-                var cardUrlAnchor = null;
-
-                function setCardUrl(url) {
-                    if (cardUrlAnchor) return; // уже есть
+                // sless_service имеет прямой URL из статуса деплоя
+                if (fn.url) {
                    var a = document.createElement('a');
                    a.className = 'fn-url';
-                    a.href = url; a.target = '_blank'; a.rel = 'noopener noreferrer';
-                    a.textContent = url;
+                    a.href = fn.url;
+                    a.target = '_blank';
+                    a.rel = 'noopener noreferrer';
+                    a.textContent = fn.url;
                    a.addEventListener('click', function (e) { e.stopPropagation(); });
-                    urlRow.appendChild(a);
-                    cardUrlAnchor = a;
+                    hdr.appendChild(a);
                }

-                if (fn.url) setCardUrl(fn.url);
-
                for (var t = 0; t < triggers.length; t++) {
                    var tr = triggers[t];
                    if (tr.type === 'http') {
+                        // Для job-style функций URL берём из триггера; для сервисов уже показан fn.url
                        if (!fn.url) {
                            var url = extURL ? extURL + '/fn/' + ns + '/' + fn.name : (tr.url || '');
-                            if (url) setCardUrl(url);
+                            if (url) {
+                                var a = document.createElement('a');
+                                a.className = 'fn-url';
+                                a.href = url;
+                                a.target = '_blank';
+                                a.rel = 'noopener noreferrer';
+                                a.textContent = url;
+                                a.addEventListener('click', function (e) { e.stopPropagation(); });
+                                hdr.appendChild(a);
+                            }
                        }
                        hdr.appendChild(makeTriggerBtn(tr, ns));
                    } else if (tr.type === 'cron') {
@@ -658,44 +405,8 @@
                    }
                }

-                // Кнопка редактирования кода
-                var editBtn = $el('button', 'action-btn');
-                editBtn.textContent = '✎';
-                editBtn.title = 'Редактировать код';
-                editBtn.addEventListener('click', function (e) {
-                    e.stopPropagation();
-                    body.innerHTML = ''; // сбрасываем содержимое перед переходом в edit
-                    loaded = false;      // следующий expand снова зачитает исходники
-                    body.style.display = 'block';
-                    icon.style.transform = 'rotate(90deg)';
-                    openEditMode(body, ns, fn.name, fn.kind, fn.runtime);
-                });
-                hdr.appendChild(editBtn);
-
-                // Кнопка удаления
-                var delBtn = $el('button', 'action-btn del');
-                delBtn.textContent = '✕';
-                delBtn.title = 'Удалить функцию';
-                delBtn.addEventListener('click', function (e) {
-                    e.stopPropagation();
-                    if (!confirm('Удалить функцию «' + fn.name + '»?\n\nЭто действие необратимо.')) return;
-                    delBtn.disabled = true;
-                    fetch('/funcs/' + ns + '/delete-function/' + fn.name + '?kind=' + (fn.kind || 'function'), {
-                        method: 'DELETE'
-                    }).then(function (r) {
-                        if (r.ok) {
-                            card.remove();
-                        } else {
-                            return r.text().then(function (t) { alert('Ошибка удаления: ' + t); });
-                        }
-                    }).catch(function (err) {
-                        alert('Сетевая ошибка: ' + err);
-                    }).finally(function () {
-                        delBtn.disabled = false;
-                    });
-                });
-                hdr.appendChild(delBtn);
-
+                if (fn.message) $txt(hdr, 'span', 'fn-msg', fn.message);
+                hdr.appendChild($el('span', 'spacer'));
                var icon = $txt(hdr, 'span', 'expand-icon', '▶');

                var loaded = false;
@@ -714,226 +425,10 @@
                });

                card.appendChild(hdr);
-                card.appendChild(urlRow);
                card.appendChild(body);
                return card;
            }

-            // openEditMode — открывает тело карточки в режиме редактирования.
-            // Загружает текущий код и файл зависимостей (requirements.txt / package.json).
-            function openEditMode(body, ns, fnName, fnKind, fnRuntime) {
-                body.innerHTML = '';
-                var msg = $el('div', 'src-msg');
-                msg.textContent = 'Загрузка кода…';
-                body.appendChild(msg);
-
-                var kindParam = fnKind === 'service' ? '?kind=service' : '';
-                fetch('/funcs/' + ns + '/source/' + fnName + kindParam)
-                    .then(function (r) {
-                        body.removeChild(msg);
-                        if (!r.ok) {
-                            var e = $el('div', 'src-msg');
-                            e.textContent = 'Ошибка загрузки кода: ' + r.status;
-                            body.appendChild(e);
-                            return;
-                        }
-                        return r.json().then(function (files) {
-                            var editable = files.filter(function (f) {
-                                return !f.binary && (f.name.endsWith('.py') || f.name.endsWith('.js'));
-                            });
-                            if (editable.length === 0) {
-                                editable = [{ name: defaultFilename(fnRuntime), content: helloWorldTemplate(fnRuntime) }];
-                            }
-                            var mainFile = editable[0];
-
-                            // Ищем файл зависимостей (requirements.txt / package.json)
-                            var tpl = TEMPLATES[fnRuntime] || {};
-                            var depsFilename = tpl.depsFilename || '';
-                            var depsContent = tpl.deps || '';
-                            if (depsFilename) {
-                                for (var i = 0; i < files.length; i++) {
-                                    if (files[i].name === depsFilename && !files[i].binary) {
-                                        depsContent = files[i].content;
-                                        break;
-                                    }
-                                }
-                            }
-
-                            renderEditArea(body, ns, fnName, fnKind, fnRuntime,
-                                mainFile.name, mainFile.content, depsFilename, depsContent);
-                        });
-                    })
-                    .catch(function (err) {
-                        body.innerHTML = '';
-                        var e = $el('div', 'src-msg');
-                        e.textContent = 'Ошибка: ' + err;
-                        body.appendChild(e);
-                    });
-            }
-
-            // renderEditArea — rename input + code textarea + deps textarea + Save/Cancel.
-            function renderEditArea(body, ns, fnName, fnKind, fnRuntime, filename, initialCode, depsFilename, depsContent) {
-                body.innerHTML = '';
-
-                // Строка переименования
-                var renameRow = $el('div', 'edit-actions');
-                renameRow.style.borderBottom = '1px solid #30363d';
-                var nameLabel = $el('span', 'edit-status');
-                nameLabel.textContent = 'Имя:';
-                var nameInput = document.createElement('input');
-                nameInput.type = 'text';
-                nameInput.value = fnName;
-                nameInput.style.cssText = 'flex:1;max-width:240px;background:#0d1117;border:1px solid #30363d;border-radius:5px;color:#e6edf3;padding:4px 8px;font-size:0.8rem;outline:none;';
-                var renameBtn = $el('button', 'edit-cancel-btn');
-                renameBtn.textContent = 'Переименовать';
-                var renameStatus = $el('span', 'edit-status');
-                renameRow.appendChild(nameLabel);
-                renameRow.appendChild(nameInput);
-                renameRow.appendChild(renameBtn);
-                renameRow.appendChild(renameStatus);
-                body.appendChild(renameRow);
-
-                // Код функции
-                var codeHdr = $el('div', 'file-header');
-                codeHdr.textContent = filename;
-                body.appendChild(codeHdr);
-                var ta = document.createElement('textarea');
-                ta.className = 'edit-area';
-                ta.spellcheck = false;
-                ta.value = initialCode;
-                body.appendChild(ta);
-
-                // Файл зависимостей (если есть)
-                var depsTA = null;
-                if (depsFilename) {
-                    var depsHdr = $el('div', 'file-header');
-                    depsHdr.textContent = depsFilename;
-                    body.appendChild(depsHdr);
-                    depsTA = document.createElement('textarea');
-                    depsTA.className = 'edit-area';
-                    depsTA.style.minHeight = '80px';
-                    depsTA.spellcheck = false;
-                    depsTA.value = depsContent;
-                    body.appendChild(depsTA);
-                }
-
-                // Кнопки Save / Cancel
-                var actions = $el('div', 'edit-actions');
-                var saveBtn = $el('button', 'edit-save-btn');
-                saveBtn.textContent = 'Сохранить';
-                var cancelBtn = $el('button', 'edit-cancel-btn');
-                cancelBtn.textContent = 'Закрыть';
-                var status = $el('span', 'edit-status');
-                actions.appendChild(saveBtn);
-                actions.appendChild(cancelBtn);
-                actions.appendChild(status);
-                body.appendChild(actions);
-
-                saveBtn.addEventListener('click', function () {
-                    saveBtn.disabled = true;
-                    status.textContent = 'Сохраняю…';
-                    status.className = 'edit-status';
-                    fetch('/funcs/' + ns + '/save-function/' + fnName, {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({
-                            code: ta.value, filename: filename, kind: fnKind || 'function',
-                            deps: depsTA ? depsTA.value : '',
-                            deps_filename: depsFilename || ''
-                        })
-                    }).then(function (r) {
-                        saveBtn.disabled = false;
-                        if (r.ok) {
-                            // Ищем phaseBadge текущей карточки через DOM
-                            var cardEl = body.closest ? body.closest('.fn-card') : null;
-                            var pb = cardEl ? cardEl.querySelector('.badge-Ready, .badge-Building, .badge-Pending, .badge-Failed, .badge-Error') : null;
-                            if (pb) { pb.className = 'badge badge-Building'; pb.textContent = 'Building'; }
-                            status.textContent = '⏳ Сборка… 0с';
-                            status.className = 'edit-status';
-                            // Запускаем поллинг: обновляет статус в строке редактора и badge карточки
-                            startBuildPoll(pb, null, { name: fnName, kind: fnKind || 'function' }, ns, status, null);
-                        } else {
-                            return r.text().then(function (t) {
-                                status.textContent = '✗ ' + t;
-                                status.className = 'edit-status err';
-                            });
-                        }
-                    }).catch(function (err) {
-                        saveBtn.disabled = false;
-                        status.textContent = '✗ ' + err;
-                        status.className = 'edit-status err';
-                    });
-                });
-
-                cancelBtn.addEventListener('click', function () { body.style.display = 'none'; });
-
-                renameBtn.addEventListener('click', function () {
-                    var newName = nameInput.value.trim();
-                    if (newName === fnName) { renameStatus.textContent = 'Имя не изменилось'; return; }
-                    if (!/^[a-z0-9]([a-z0-9\-]{0,61}[a-z0-9])?$/.test(newName)) {
-                        renameStatus.textContent = '✗ Только строчные буквы, цифры, дефисы';
-                        renameStatus.className = 'edit-status err';
-                        return;
-                    }
-                    renameBtn.disabled = true;
-                    renameStatus.textContent = 'Переименовываю…';
-                    renameStatus.className = 'edit-status';
-                    fetch('/funcs/' + ns + '/rename-function/' + fnName, {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({ new_name: newName, kind: fnKind || 'function' })
-                    }).then(function (r) {
-                        if (r.ok) {
-                            renameStatus.textContent = '✓ Переименовано → ' + newName;
-                            renameStatus.className = 'edit-status ok';
-                            setTimeout(function () { location.reload(); }, 800);
-                        } else {
-                            return r.text().then(function (t) {
-                                renameStatus.textContent = '✗ ' + t;
-                                renameStatus.className = 'edit-status err';
-                            });
-                        }
-                    }).catch(function (err) {
-                        renameStatus.textContent = '✗ ' + err;
-                        renameStatus.className = 'edit-status err';
-                    }).finally(function () { renameBtn.disabled = false; });
-                });
-            }
-
-            // startBuildPoll — опрашивает /fn-status каждые 5с пока phase=Building/Pending.
-            // Показывает таймер-строку в statusEl (если передан), обновляет phaseBadge,
-            // добавляет URL через onUrl-коллбэк когда сервис появляется.
-            function startBuildPoll(phaseBadge, timerEl, fn, ns, statusEl, onUrl) {
-                var buildStart = Date.now();
-                var timerItv = setInterval(function () {
-                    var sec = Math.floor((Date.now() - buildStart) / 1000);
-                    if (timerEl && timerEl.parentNode) timerEl.textContent = sec + 'с';
-                    if (statusEl) statusEl.textContent = '⏳ Сборка… ' + sec + 'с';
-                }, 1000);
-                var pollItv = setInterval(function () {
-                    fetch('/funcs/' + ns + '/fn-status/' + fn.name + '?kind=' + (fn.kind || 'function'))
-                        .then(function (r) { return r.json(); })
-                        .then(function (d) {
-                            if (!d.phase || d.phase === 'Building' || d.phase === 'Pending') return;
-                            clearInterval(timerItv);
-                            clearInterval(pollItv);
-                            if (phaseBadge) {
-                                phaseBadge.className = 'badge badge-' + d.phase;
-                                phaseBadge.textContent = d.phase;
-                            }
-                            if (timerEl && timerEl.parentNode) timerEl.parentNode.removeChild(timerEl);
-                            if (statusEl) {
-                                statusEl.textContent = d.phase === 'Ready'
-                                    ? '✓ Сборка завершена — функция готова'
-                                    : '✗ Сборка завершилась со статусом: ' + d.phase;
-                                statusEl.className = 'edit-status ' + (d.phase === 'Ready' ? 'ok' : 'err');
-                            }
-                            if (d.url && onUrl) onUrl(d.url);
-                        })
-                        .catch(function () {});
-                }, 5000);
-            }
-
            function makeTriggerBtn(tr, ns) {
                var btn = $el('button', 'trigger-btn ' + (tr.enabled ? 'state-on' : 'state-off'));
                btn.textContent = tr.enabled ? '■ стоп' : '▶ запуск';
@@ -964,7 +459,6 @@
            }

            function loadSource(body, ns, fnName, fnKind) {
-                body.innerHTML = ''; // всегда очищаем перед загрузкой
                var msg = $el('div', 'src-msg');
                msg.textContent = 'Загрузка кода…';
                body.appendChild(msg);
@@ -1012,120 +506,6 @@
                    });
            }

-            // ---------- Модалка создания функции ----------
-
-            var TEMPLATES = {
-                'python3.11': {
-                    filename: 'handler.py',
-                    code: '# Hello World — Python 3.11\n# Entrypoint: handler.handler\n\ndef handler(event):\n    name = event.get("name", "World")\n    return {"result": f"Hello, {name}!"}\n',
-                    depsFilename: 'requirements.txt',
-                    deps: '# Python packages\n# e.g.: requests==2.31.0\n'
-                },
-                'nodejs20': {
-                    filename: 'handler.js',
-                    code: '// Hello World — Node.js 20\n// Entrypoint: handler.handler\n\nexports.handler = async (event) => {\n    const name = event.name || \'World\';\n    return { result: `Hello, ${name}!` };\n};\n',
-                    depsFilename: 'package.json',
-                    deps: '{\n  "dependencies": {}\n}\n'
-                }
-            };
-
-            function defaultFilename(runtime) {
-                return TEMPLATES[runtime] ? TEMPLATES[runtime].filename : 'handler.py';
-            }
-            function helloWorldTemplate(runtime) {
-                return TEMPLATES[runtime] ? TEMPLATES[runtime].code : '# код функции\n';
-            }
-
-            var modal = document.getElementById('create-modal');
-            var mRuntime = document.getElementById('m-runtime');
-            var mCode = document.getElementById('m-code');
-            var mFilenameDisplay = document.getElementById('m-filename-display');
-            var mErr = document.getElementById('m-err');
-
-            // Заполняем шаблон при открытии / смене runtime
-            function applyTemplate() {
-                var tpl = TEMPLATES[mRuntime.value];
-                if (tpl) {
-                    mCode.value = tpl.code;
-                    mFilenameDisplay.textContent = tpl.filename;
-                    document.getElementById('m-deps-name').textContent = tpl.depsFilename;
-                    document.getElementById('m-deps').value = tpl.deps || '';
-                }
-            }
-            applyTemplate();
-            mRuntime.addEventListener('change', applyTemplate);
-
-            document.getElementById('open-create-modal').addEventListener('click', function () {
-                applyTemplate();
-                mErr.textContent = '';
-                document.getElementById('m-name').value = '';
-                document.getElementById('m-entrypoint').value = 'handler.handler';
-                modal.classList.add('open');
-                document.getElementById('m-name').focus();
-            });
-
-            document.getElementById('modal-cancel').addEventListener('click', function () {
-                modal.classList.remove('open');
-            });
-            modal.addEventListener('click', function (e) {
-                if (e.target === modal) modal.classList.remove('open');
-            });
-
-            document.getElementById('modal-submit').addEventListener('click', function () {
-                var name = document.getElementById('m-name').value.trim();
-                var runtime = mRuntime.value;
-                var entrypoint = document.getElementById('m-entrypoint').value.trim();
-                var code = mCode.value;
-                var filename = TEMPLATES[runtime] ? TEMPLATES[runtime].filename : 'handler.py';
-
-                mErr.textContent = '';
-                if (!name) { mErr.textContent = 'Укажите имя функции'; return; }
-                if (!/^[a-z0-9][a-z0-9\-]{0,61}[a-z0-9]$/.test(name) && !/^[a-z0-9]$/.test(name)) {
-                    mErr.textContent = 'Имя должно быть в формате k8s: строчные буквы, цифры, дефисы';
-                    return;
-                }
-                if (!entrypoint) { mErr.textContent = 'Укажите entrypoint (например handler.handler)'; return; }
-                if (!code.trim()) { mErr.textContent = 'Напишите код функции'; return; }
-
-                var btn = document.getElementById('modal-submit');
-                btn.disabled = true;
-                mErr.textContent = 'Создаю…';
-
-                fetch('/funcs/' + ns + '/create-function', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        name: name,
-                        runtime: runtime,
-                        kind: 'service',
-                        code: code,
-                        filename: filename,
-                        entrypoint: entrypoint,
-                        memory_mb: 128,
-                        timeout_sec: 30,
-                        deps: document.getElementById('m-deps').value,
-                        deps_filename: TEMPLATES[runtime] ? TEMPLATES[runtime].depsFilename : ''
-                    })
-                }).then(function (r) {
-                    if (r.ok) {
-                        modal.classList.remove('open');
-                        mErr.textContent = '';
-                        // Перезагружаем страницу чтобы увидеть новую функцию
-                        setTimeout(function () { location.reload(); }, 400);
-                    } else {
-                        return r.text().then(function (t) {
-                            mErr.textContent = '✗ ' + t;
-                        });
-                    }
-                }).catch(function (err) {
-                    mErr.textContent = '✗ Сетевая ошибка: ' + err;
-                }).finally(function () {
-                    btn.disabled = false;
-                });
-            });
-
-            // ---------- Утилиты ----------
-
            function detectLang(name) {
                var ext = name.split('.').pop().toLowerCase();
                var m = {
@@ -1,20 +1,15 @@
-// Изменено: 2026-03-23 (deps поддержка, Building poll, rename, kind=service по умолч.)
+// Изменено: 2026-03-21 (добавлен вывод sless_service вместе с функциями — пользователь видит оба типа как «функции»)
 // main.go — глобальный HTTP сервис листинга функций пользователя.
 // Развёрнут ОДИН РАЗ в namespace sless; работает для ВСЕХ пользователей.
 // Не связан с terraform — деплоится манифестом deployments/k8s/funcs-service.yaml.
 //
 // Маршруты:
-//   GET  /funcs                                    — usage hint (без токена)
-//   GET  /funcs?token=<jwt>                         — листинг через JWT токен
-//   GET  /funcs/<namespace>                         — листинг (Accept: text/html → HTML, иначе plain text)
-//   GET  /funcs/<namespace>/source/<fn>             — прокси: исходный код (JSON)
-//   PATCH /funcs/<namespace>/triggers/<n>           — прокси: enable/disable триггера
-//   GET  /funcs/<namespace>/fn-status/<fn>          — прокси: текущий phase+url функции (для UI polling)
-//   POST /funcs/<namespace>/create-function         — создать функцию через UI (kind=service по умолч.)
-//   POST /funcs/<namespace>/save-function/<fn>      — обновить код через UI (zip с code+deps)
-//   POST /funcs/<namespace>/rename-function/<fn>    — переименовать: delete old + create new с тем же кодом
-//   DELETE /funcs/<namespace>/delete-function/<fn>  — удалить функцию через UI
-//   GET  /health                                    — liveness/readiness probe
+//   GET  /funcs                            — usage hint (без токена)
+//   GET  /funcs?token=<jwt>                — листинг через JWT токен
+//   GET  /funcs/<namespace>                — листинг (Accept: text/html → HTML, иначе plain text)
+//   GET  /funcs/<namespace>/source/<fn>    — прокси к оператору: файлы исходного кода (JSON)
+//   PATCH /funcs/<namespace>/triggers/<n>  — прокси к оператору: enable/disable триггера
+//   GET  /health                           — liveness/readiness probe
 //
 // Env vars:
 //   SLESS_OPERATOR_URL  — URL оператора внутри кластера (default: http://sless-operator.sless.svc.cluster.local:9090)
@@ -26,9 +21,7 @@
 package main

 import (
-	"archive/zip"
 	"bytes"
-	"context"
 	"crypto/sha256"
 	_ "embed"
 	"encoding/base64"
@@ -36,7 +29,6 @@ import (
 	"fmt"
 	"io"
 	"log"
-	"mime/multipart"
 	"net/http"
 	"os"
 	"regexp"
@@ -188,51 +180,9 @@ func handleFuncsNS(operatorURL, externalURL, serviceToken string, exclude map[st
 				}
 				proxyTriggerPatch(w, r, operatorURL, serviceToken, ns, parts[2])
 				return
-			case "fn-status":
-				// GET /funcs/{ns}/fn-status/{fn} — текущий phase+url для UI polling
-				if r.Method != http.MethodGet {
-					http.Error(w, "method not allowed\n", http.StatusMethodNotAllowed)
-					return
-				}
-				proxyFnStatus(w, r, operatorURL, serviceToken, ns, parts[2])
-				return
-			case "save-function":
-				// POST /funcs/{ns}/save-function/{fnName} — обновить код функции через UI
-				if r.Method != http.MethodPost {
-					http.Error(w, "method not allowed\n", http.StatusMethodNotAllowed)
-					return
-				}
-				proxySaveFunction(w, r, operatorURL, serviceToken, ns, parts[2])
-				return
-			case "rename-function":
-				// POST /funcs/{ns}/rename-function/{fn} — переименовать: delete+create с тем же кодом
-				if r.Method != http.MethodPost {
-					http.Error(w, "method not allowed\n", http.StatusMethodNotAllowed)
-					return
-				}
-				proxyRenameFunction(w, r, operatorURL, serviceToken, ns, parts[2])
-				return
-			case "delete-function":
-				// DELETE /funcs/{ns}/delete-function/{fnName} — удалить функцию через UI
-				if r.Method != http.MethodDelete {
-					http.Error(w, "method not allowed\n", http.StatusMethodNotAllowed)
-					return
-				}
-				proxyDeleteFunction(w, r, operatorURL, serviceToken, ns, parts[2])
-				return
 			}
 		}

-		if len(parts) == 2 && parts[1] == "create-function" {
-			// POST /funcs/{ns}/create-function — создать новую функцию через UI
-			if r.Method != http.MethodPost {
-				http.Error(w, "method not allowed\n", http.StatusMethodNotAllowed)
-				return
-			}
-			proxyCreateFunction(w, r, operatorURL, serviceToken, ns)
-			return
-		}
-
 		if len(parts) > 1 {
 			http.NotFound(w, r)
 			return
@@ -599,344 +549,3 @@ func env(key, fallback string) string {
 	}
 	return fallback
 }
-
-// proxyCreateFunction обрабатывает POST /funcs/{ns}/create-function.
-// Создаёт функцию как sless_service (always-on, с URL) если kind не указан.
-// Принимает code (основной файл) + deps (requirements.txt / package.json).
-func proxyCreateFunction(w http.ResponseWriter, r *http.Request, operatorURL, serviceToken, ns string) {
-	var req struct {
-		Name       string `json:"name"`
-		Runtime    string `json:"runtime"`
-		Kind       string `json:"kind"` // "service" | "function"; default "service"
-		Code       string `json:"code"`
-		Filename   string `json:"filename"`
-		Deps       string `json:"deps"`          // содержимое requirements.txt / package.json
-		DepsFile   string `json:"deps_filename"` // "requirements.txt" или "package.json"
-		Entrypoint string `json:"entrypoint"`
-		MemoryMB   int    `json:"memory_mb"`
-		TimeoutSec int    `json:"timeout_sec"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, `{"error":"invalid JSON"}`, http.StatusBadRequest)
-		return
-	}
-	if req.Name == "" || req.Runtime == "" || req.Code == "" || req.Filename == "" || req.Entrypoint == "" {
-		http.Error(w, `{"error":"name, runtime, code, filename, entrypoint are required"}`, http.StatusBadRequest)
-		return
-	}
-	if !isValidK8sName(req.Name) {
-		http.Error(w, `{"error":"invalid function name"}`, http.StatusBadRequest)
-		return
-	}
-	if req.Kind == "" {
-		req.Kind = "service" // always-on по умолчанию — сразу получает URL
-	}
-	if req.MemoryMB <= 0 {
-		req.MemoryMB = 128
-	}
-	if req.TimeoutSec <= 0 {
-		req.TimeoutSec = 30
-	}
-
-	resourceType := "functions"
-	if req.Kind == "service" {
-		resourceType = "services"
-	}
-
-	// Шаг 1: создаём CRD через оператор (/functions или /services)
-	createBody, _ := json.Marshal(map[string]any{
-		"name":        req.Name,
-		"runtime":     req.Runtime,
-		"entrypoint":  req.Entrypoint,
-		"memory_mb":   req.MemoryMB,
-		"timeout_sec": req.TimeoutSec,
-	})
-	createURL := operatorURL + "/v1/namespaces/" + ns + "/" + resourceType
-	createResp, err := operatorRequest(r.Context(), http.MethodPost, createURL, serviceToken, "application/json", bytes.NewReader(createBody))
-	if err != nil || (createResp.StatusCode != http.StatusCreated && createResp.StatusCode != http.StatusOK) {
-		code := http.StatusBadGateway
-		msg := "create CRD failed"
-		if createResp != nil {
-			b, _ := io.ReadAll(createResp.Body)
-			createResp.Body.Close()
-			msg = string(b)
-			code = createResp.StatusCode
-		}
-		http.Error(w, msg, code)
-		return
-	}
-	createResp.Body.Close()
-
-	// Шаг 2: упаковываем code + deps в zip и загружаем
-	zipFiles := map[string]string{req.Filename: req.Code}
-	if req.Deps != "" && req.DepsFile != "" {
-		zipFiles[req.DepsFile] = req.Deps
-	}
-	zipData, err := buildZipFiles(zipFiles)
-	if err != nil {
-		http.Error(w, `{"error":"zip build failed"}`, http.StatusInternalServerError)
-		return
-	}
-	uploadURL := operatorURL + "/v1/namespaces/" + ns + "/" + resourceType + "/" + req.Name + "/upload"
-	if err := uploadZipToOperator(r.Context(), uploadURL, serviceToken, req.Filename, zipData); err != nil {
-		http.Error(w, "upload code: "+err.Error(), http.StatusBadGateway)
-		return
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusCreated)
-	fmt.Fprintf(w, `{"status":"ok","name":%q,"kind":%q}`, req.Name, req.Kind)
-}
-
-// proxySaveFunction обрабатывает POST /funcs/{ns}/save-function/{fnName}.
-// Принимает code + deps (опционально), упаковывает в zip и загружает через оператор.
-// kind=service → загружает в /services/{name}/upload, иначе → /functions/{name}/upload.
-func proxySaveFunction(w http.ResponseWriter, r *http.Request, operatorURL, serviceToken, ns, fnName string) {
-	if !isValidK8sName(fnName) {
-		http.Error(w, `{"error":"invalid function name"}`, http.StatusBadRequest)
-		return
-	}
-	var req struct {
-		Code     string `json:"code"`
-		Filename string `json:"filename"`
-		Kind     string `json:"kind"`          // "function" | "service"
-		Deps     string `json:"deps"`          // содержимое requirements.txt / package.json
-		DepsFile string `json:"deps_filename"` // имя файла зависимостей
-	}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.Code == "" || req.Filename == "" {
-		http.Error(w, `{"error":"code and filename are required"}`, http.StatusBadRequest)
-		return
-	}
-
-	zipFiles := map[string]string{req.Filename: req.Code}
-	if req.Deps != "" && req.DepsFile != "" {
-		zipFiles[req.DepsFile] = req.Deps
-	}
-	zipData, err := buildZipFiles(zipFiles)
-	if err != nil {
-		http.Error(w, `{"error":"zip build failed"}`, http.StatusInternalServerError)
-		return
-	}
-
-	resourceType := "functions"
-	if req.Kind == "service" {
-		resourceType = "services"
-	}
-	uploadURL := operatorURL + "/v1/namespaces/" + ns + "/" + resourceType + "/" + fnName + "/upload"
-	if err := uploadZipToOperator(r.Context(), uploadURL, serviceToken, req.Filename, zipData); err != nil {
-		http.Error(w, "upload code: "+err.Error(), http.StatusBadGateway)
-		return
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	fmt.Fprintf(w, `{"status":"ok","name":%q}`, fnName)
-}
-
-// proxyDeleteFunction обрабатывает DELETE /funcs/{ns}/delete-function/{fnName}.
-// Проксирует DELETE к оператору. kind=service → /services/{name}, иначе → /functions/{name}.
-func proxyDeleteFunction(w http.ResponseWriter, r *http.Request, operatorURL, serviceToken, ns, fnName string) {
-	if !isValidK8sName(fnName) {
-		http.Error(w, `{"error":"invalid function name"}`, http.StatusBadRequest)
-		return
-	}
-	resourceType := "functions"
-	if r.URL.Query().Get("kind") == "service" {
-		resourceType = "services"
-	}
-	target := operatorURL + "/v1/namespaces/" + ns + "/" + resourceType + "/" + fnName
-	resp, err := operatorRequest(r.Context(), http.MethodDelete, target, serviceToken, "", nil)
-	if err != nil {
-		http.Error(w, "operator error: "+err.Error(), http.StatusBadGateway)
-		return
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode >= 300 {
-		b, _ := io.ReadAll(resp.Body)
-		http.Error(w, string(b), resp.StatusCode)
-		return
-	}
-	w.Header().Set("Content-Type", "application/json")
-	fmt.Fprintf(w, `{"status":"ok","name":%q}`, fnName)
-}
-
-// buildZipFiles упаковывает набор текстовых файлов {filename→content} в zip-архив.
-// Используется при создании/редактировании функций через UI.
-// Поддерживает code + deps (requirements.txt / package.json) в одном архиве.
-func buildZipFiles(files map[string]string) ([]byte, error) {
-	var buf bytes.Buffer
-	zw := zip.NewWriter(&buf)
-	for name, content := range files {
-		f, err := zw.Create(name)
-		if err != nil {
-			return nil, err
-		}
-		if _, err := io.WriteString(f, content); err != nil {
-			return nil, err
-		}
-	}
-	if err := zw.Close(); err != nil {
-		return nil, err
-	}
-	return buf.Bytes(), nil
-}
-
-// proxyFnStatus отдаёт текущий phase+url функции/сервиса — используется для UI polling.
-// Клиент опрашивает каждые 5с пока phase=Building, потом останавливается.
-func proxyFnStatus(w http.ResponseWriter, r *http.Request, operatorURL, serviceToken, ns, fnName string) {
-	if !isValidK8sName(fnName) {
-		http.Error(w, `{"error":"invalid name"}`, http.StatusBadRequest)
-		return
-	}
-	resourceType := "functions"
-	if r.URL.Query().Get("kind") == "service" {
-		resourceType = "services"
-	}
-	resp, err := operatorRequest(r.Context(), http.MethodGet,
-		operatorURL+"/v1/namespaces/"+ns+"/"+resourceType+"/"+fnName, serviceToken, "", nil)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusBadGateway)
-		return
-	}
-	defer resp.Body.Close()
-	b, _ := io.ReadAll(resp.Body)
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(resp.StatusCode)
-	w.Write(b) //nolint:errcheck
-}
-
-// proxyRenameFunction реализует переименование функции: delete old + create new + upload old code.
-// Это атомарная операция с точки зрения UI, но не транзакционная на уровне k8s.
-// При сбое на шагах 3-5 старая функция может остаться (UI покажет ошибку).
-func proxyRenameFunction(w http.ResponseWriter, r *http.Request, operatorURL, serviceToken, ns, oldName string) {
-	if !isValidK8sName(oldName) {
-		http.Error(w, `{"error":"invalid old name"}`, http.StatusBadRequest)
-		return
-	}
-	var req struct {
-		NewName string `json:"new_name"`
-		Kind    string `json:"kind"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.NewName == "" {
-		http.Error(w, `{"error":"new_name required"}`, http.StatusBadRequest)
-		return
-	}
-	if !isValidK8sName(req.NewName) {
-		http.Error(w, `{"error":"invalid new_name"}`, http.StatusBadRequest)
-		return
-	}
-	resourceType := "functions"
-	if req.Kind == "service" {
-		resourceType = "services"
-	}
-	ctx := r.Context()
-	baseURL := operatorURL + "/v1/namespaces/" + ns + "/" + resourceType
-
-	// Шаг 1: получаем конфиг старой функции (runtime, entrypoint, memory, timeout)
-	cfgResp, err := operatorRequest(ctx, http.MethodGet, baseURL+"/"+oldName, serviceToken, "", nil)
-	if err != nil || cfgResp.StatusCode != http.StatusOK {
-		http.Error(w, "get old config failed", http.StatusBadGateway)
-		return
-	}
-	var cfg struct {
-		Runtime    string            `json:"runtime"`
-		Entrypoint string            `json:"entrypoint"`
-		MemoryMB   int               `json:"memory_mb"`
-		TimeoutSec int               `json:"timeout_sec"`
-		Env        map[string]string `json:"env"`
-	}
-	json.NewDecoder(cfgResp.Body).Decode(&cfg) //nolint:errcheck
-	cfgResp.Body.Close()
-
-	// Шаг 2: получаем исходный код старой функции
-	srcResp, _ := operatorRequest(ctx, http.MethodGet, baseURL+"/"+oldName+"/source", serviceToken, "", nil)
-	zipFiles := map[string]string{}
-	if srcResp != nil && srcResp.StatusCode == http.StatusOK {
-		var files []struct {
-			Name    string `json:"name"`
-			Content string `json:"content"`
-			Binary  bool   `json:"binary"`
-		}
-		if json.NewDecoder(srcResp.Body).Decode(&files) == nil {
-			for _, f := range files {
-				if !f.Binary {
-					zipFiles[f.Name] = f.Content
-				}
-			}
-		}
-		srcResp.Body.Close()
-	}
-
-	// Шаг 3: создаём новую функцию с новым именем
-	createBody, _ := json.Marshal(map[string]any{
-		"name": req.NewName, "runtime": cfg.Runtime, "entrypoint": cfg.Entrypoint,
-		"memory_mb": cfg.MemoryMB, "timeout_sec": cfg.TimeoutSec, "env": cfg.Env,
-	})
-	createResp, err := operatorRequest(ctx, http.MethodPost, baseURL, serviceToken, "application/json", bytes.NewReader(createBody))
-	if err != nil || (createResp.StatusCode != http.StatusCreated && createResp.StatusCode != http.StatusOK) {
-		msg := "create new failed"
-		if createResp != nil {
-			b, _ := io.ReadAll(createResp.Body)
-			createResp.Body.Close()
-			msg = string(b)
-		}
-		http.Error(w, msg, http.StatusBadGateway)
-		return
-	}
-	createResp.Body.Close()
-
-	// Шаг 4: загружаем старый код в новую функцию (если есть)
-	if len(zipFiles) > 0 {
-		if zipData, err := buildZipFiles(zipFiles); err == nil {
-			_ = uploadZipToOperator(ctx, baseURL+"/"+req.NewName+"/upload", serviceToken, req.NewName, zipData)
-		}
-	}
-
-	// Шаг 5: удаляем старую функцию
-	delResp, _ := operatorRequest(ctx, http.MethodDelete, baseURL+"/"+oldName, serviceToken, "", nil)
-	if delResp != nil {
-		delResp.Body.Close()
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	fmt.Fprintf(w, `{"status":"ok","old":%q,"new":%q,"kind":%q}`, oldName, req.NewName, req.Kind)
-}
-
-// uploadZipToOperator отправляет zip-данные как multipart/form-data field "code" на URL оператора.
-func uploadZipToOperator(ctx context.Context, url, token, filename string, zipData []byte) error {
-	var body bytes.Buffer
-	mw := multipart.NewWriter(&body)
-	fw, err := mw.CreateFormFile("code", filename+".zip")
-	if err != nil {
-		return err
-	}
-	if _, err := fw.Write(zipData); err != nil {
-		return err
-	}
-	mw.Close()
-
-	resp, err := operatorRequest(ctx, http.MethodPost, url, token, mw.FormDataContentType(), &body)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode >= 300 {
-		b, _ := io.ReadAll(resp.Body)
-		return fmt.Errorf("status %d: %s", resp.StatusCode, b)
-	}
-	return nil
-}
-
-// operatorRequest выполняет HTTP-запрос к оператору с авторизацией через serviceToken.
-func operatorRequest(ctx context.Context, method, url, token, contentType string, body io.Reader) (*http.Response, error) {
-	req, err := http.NewRequestWithContext(ctx, method, url, body)
-	if err != nil {
-		return nil, err
-	}
-	if token != "" {
-		req.Header.Set("Authorization", "Bearer "+token)
-	}
-	if contentType != "" {
-		req.Header.Set("Content-Type", contentType)
-	}
-	return http.DefaultClient.Do(req)
-}
@@ -253,23 +253,15 @@ func (r *JobResource) Create(ctx context.Context, req resource.CreateRequest, re
 		}
 	}

-	// Загружаем код если задан source_dir — контроллер начнёт kaniko сборку после upload.
-	// deleteOnFail — откат: удаляем CR если upload провалился,
-	// иначе при следующем apply будет 409 (CR есть, state пустой).
+	// Загружаем код если задан source_dir — контроллер начнёт kaniko сборку после upload
 	if !plan.SourceDir.IsNull() && plan.SourceDir.ValueString() != "" {
 		zipData, hash, err := zipDir(plan.SourceDir.ValueString())
 		if err != nil {
 			resp.Diagnostics.AddError("zip source_dir", err.Error())
-			if delErr := r.client.DeleteJob(ctx, ns, plan.Name.ValueString()); delErr != nil {
-				resp.Diagnostics.AddWarning("rollback delete job", delErr.Error())
-			}
 			return
 		}
 		if err := r.client.UploadJobCode(ctx, ns, plan.Name.ValueString(), "function.zip", bytes.NewReader(zipData)); err != nil {
 			resp.Diagnostics.AddError("upload job code", err.Error())
-			if delErr := r.client.DeleteJob(ctx, ns, plan.Name.ValueString()); delErr != nil {
-				resp.Diagnostics.AddWarning("rollback delete job", delErr.Error())
-			}
 			return
 		}
 		plan.CodeHash = types.StringValue(hash)
@@ -192,31 +192,22 @@ func (r *ServiceResource) Create(ctx context.Context, req resource.CreateRequest
 		return
 	}

-	// deleteOnFail — откат: удаляем CR если upload провалился,
-	// иначе при следующем apply будет 409 (CR есть, state пустой).
-	deleteOnFail := func(addErr string, err error) {
-		resp.Diagnostics.AddError(addErr, err.Error())
-		if delErr := r.client.DeleteService(ctx, ns, svc.Name); delErr != nil {
-			resp.Diagnostics.AddWarning("rollback delete service", delErr.Error())
-		}
-	}
-
 	var codeUploaded bool
 	if !plan.SourceDir.IsNull() && plan.SourceDir.ValueString() != "" {
 		zipData, hash, err := zipDir(plan.SourceDir.ValueString())
 		if err != nil {
-			deleteOnFail("zip source_dir", err)
+			resp.Diagnostics.AddError("zip source_dir", err.Error())
 			return
 		}
 		if err := r.client.UploadServiceCodeReader(ctx, ns, svc.Name, "code.zip", bytes.NewReader(zipData)); err != nil {
-			deleteOnFail("upload service code", err)
+			resp.Diagnostics.AddError("upload service code", err.Error())
 			return
 		}
 		plan.CodeHash = types.StringValue(hash)
 		codeUploaded = true
 	} else if !plan.CodePath.IsNull() && plan.CodePath.ValueString() != "" {
 		if err := r.client.UploadServiceCode(ctx, ns, svc.Name, plan.CodePath.ValueString()); err != nil {
-			deleteOnFail("upload service code", err)
+			resp.Diagnostics.AddError("upload service code", err.Error())
 			return
 		}
 		codeUploaded = true