@avytheone/efmesh 0.1.0-beta.1

package/src/discovery.ts

@@ -0,0 +1,77 @@
+import * as NodePath from "node:path"
+import { Data, Effect } from "effect"
+import type { AnyModel } from "./core/model.ts"
+
+/**
+ * Discovery моделей по glob (SPEC §12): файлы по маскам из конфига
+ * импортируются, все экспорты-модели (defineModel/defineExternal/defineSeed/
+ * defineSqlModel — у всех _tag: "Model") собираются в проект. Порядок —
+ * детерминированный (сортировка путей), два разных определения с одним
+ * именем — ошибка загрузки; один и тот же объект, реэкспортированный из
+ * нескольких файлов, считается один раз.
+ */
+
+export class DiscoveryError extends Data.TaggedError("DiscoveryError")<{
+  readonly path: string
+  readonly reason: string
+}> {}
+
+export class DiscoveryConflictError extends Data.TaggedError("DiscoveryConflictError")<{
+  readonly name: string
+  readonly files: ReadonlyArray<string>
+}> {}
+
+const isModel = (value: unknown): value is AnyModel =>
+  typeof value === "object" &&
+  value !== null &&
+  (value as { _tag?: unknown })._tag === "Model" &&
+  typeof (value as { name?: { full?: unknown } }).name?.full === "string"
+
+const scanPattern = (pattern: string, root: string): Effect.Effect<ReadonlyArray<string>, DiscoveryError> =>
+  Effect.tryPromise({
+    try: async () => {
+      const found: Array<string> = []
+      for await (const file of new Bun.Glob(pattern).scan({ cwd: root, absolute: true })) {
+        found.push(file)
+      }
+      return found
+    },
+    catch: (cause) => new DiscoveryError({ path: pattern, reason: String(cause) }),
+  })
+
+export const discoverModels = (
+  patterns: string | ReadonlyArray<string>,
+  root: string,
+): Effect.Effect<ReadonlyArray<AnyModel>, DiscoveryError | DiscoveryConflictError> =>
+  Effect.gen(function* () {
+    const masks = typeof patterns === "string" ? [patterns] : patterns
+    const files = new Set<string>()
+    for (const mask of masks) {
+      for (const file of yield* scanPattern(mask, root)) files.add(file)
+    }
+
+    const models: Array<AnyModel> = []
+    const seen = new Set<AnyModel>()
+    const owner = new Map<string, string>()
+    for (const file of [...files].sort()) {
+      const module = yield* Effect.tryPromise({
+        try: () => import(file) as Promise<Record<string, unknown>>,
+        catch: (cause) => new DiscoveryError({ path: file, reason: String(cause) }),
+      })
+      for (const value of Object.values(module)) {
+        if (!isModel(value) || seen.has(value)) continue
+        const relative = NodePath.relative(root, file)
+        const already = owner.get(value.name.full)
+        if (already !== undefined) {
+          return yield* new DiscoveryConflictError({
+            name: value.name.full,
+            files: [already, relative],
+          })
+        }
+        seen.add(value)
+        owner.set(value.name.full, relative)
+        models.push(value)
+      }
+    }
+    return models
+  })

package/src/efmesh.ts

@@ -0,0 +1,94 @@
+import { Effect } from "effect"
+import { buildGraph } from "./core/graph.ts"
+import type { AnyModel } from "./core/model.ts"
+import { render } from "./core/sql.ts"
+import type { EngineError, SqlParseError } from "./engine/adapter.ts"
+import { EngineAdapter } from "./engine/adapter.ts"
+import { canonicalSql } from "./plan/fingerprint.ts"
+import {
+  applyPlan,
+  type AppliedPlan,
+  type ApplyError,
+  type ApplyOptions,
+} from "./plan/executor.ts"
+import { envLockName, withStateLock, type LockHeldError, type LockOptions } from "./plan/lock.ts"
+import {
+  planChanges,
+  type FingerprintVersionError,
+  type ForwardOnlyError,
+  type InvalidEnvironmentError,
+  type Plan,
+  type PlanOptions,
+} from "./plan/planner.ts"
+import type { SeedReadError } from "./core/errors.ts"
+import type { GraphError } from "./core/graph.ts"
+import type { StateError } from "./state/store.ts"
+import { StateStore } from "./state/store.ts"
+import { externalSourceRef, viewRef } from "./plan/naming.ts"
+
+/**
+ * Фасад efmesh (SPEC §10): обычные Effect'ы, встраиваемые в любое
+ * приложение; CLI — тонкая обёртка над ними.
+ */
+export const Efmesh = {
+  /** Посчитать план для окружения, ничего не меняя. Движок нужен для канонизации SQL. */
+  plan: (
+    env: string,
+    models: Iterable<AnyModel>,
+    options?: PlanOptions,
+  ): Effect.Effect<
+    Plan,
+    | GraphError
+    | StateError
+    | InvalidEnvironmentError
+    | ForwardOnlyError
+    | FingerprintVersionError
+    | EngineError
+    | SqlParseError
+    | SeedReadError,
+    StateStore | EngineAdapter
+  > => buildGraph(models).pipe(Effect.flatMap((graph) => planChanges(env, graph, options))),
+
+  /**
+   * План + применение: физика, бэкфилл интервалов, view-слой, состояние.
+   * Идёт под межпроцессным локом `env:<имя>` (SPEC §14.6) — тем же, что у
+   * run: параллельные мутации окружения из разных процессов отсекаются.
+   */
+  apply: (
+    env: string,
+    models: Iterable<AnyModel>,
+    options?: PlanOptions & ApplyOptions & LockOptions,
+  ): Effect.Effect<AppliedPlan, ApplyError | LockHeldError, EngineAdapter | StateStore> =>
+    Effect.gen(function* () {
+      const graph = yield* buildGraph(models)
+      const plan = yield* planChanges(env, graph, options)
+      return yield* applyPlan(plan, graph, options)
+    }).pipe(withStateLock(envLockName(env), options?.lockTtlMs)),
+
+  /** Canonical-рендер SQL модели (ссылки — логические имена) для отладки. */
+  render: (models: Iterable<AnyModel>, name: string): Effect.Effect<string, GraphError> =>
+    buildGraph(models).pipe(Effect.map((graph) => canonicalSql(graph, name))),
+
+  /** Рендер SQL модели против view-слоя окружения — «как выполнит движок». */
+  renderFor: (
+    models: Iterable<AnyModel>,
+    name: string,
+    env: string,
+  ): Effect.Effect<string, GraphError> =>
+    buildGraph(models).pipe(
+      Effect.map((graph) => {
+        const model = graph.models.get(name)
+        if (model === undefined) throw new Error(`модели ${name} нет в проекте`)
+        // view-слоя у external и embedded нет: источник как есть / подзапрос
+        const resolve = (ref: string): string => {
+          const source = graph.models.get(ref)!
+          if (source.kind._tag === "external") return externalSourceRef(source.kind.source)
+          if (source.kind._tag === "embedded") {
+            return `(${render(source.fragment, { resolveRef: resolve })})`
+          }
+          return viewRef(env, source.name)
+        }
+        return render(model.fragment, { resolveRef: resolve })
+      }),
+    ),
+} as const

package/src/engine/adapter.ts

@@ -0,0 +1,52 @@
+import { Context, Data, Effect } from "effect"
+
+export class EngineError extends Data.TaggedError("EngineError")<{
+  readonly sql: string
+  readonly cause: unknown
+}> {}
+
+/** Движок не смог распарсить SQL модели (SPEC §9.2). */
+export class SqlParseError extends Data.TaggedError("SqlParseError")<{
+  readonly sql: string
+  readonly message: string
+}> {}
+
+export interface EngineColumn {
+  readonly name: string
+  readonly type: string
+}
+
+/**
+ * Адаптер движка (SPEC §9.1). Минимальная поверхность: DDL-помощники
+ * живут отдельно (executor) и ходят через execute — адаптеру незачем
+ * знать про физический/виртуальный слой.
+ */
+export type Dialect = "duckdb" | "postgres"
+
+export interface Engine {
+  readonly dialect: Dialect
+  readonly query: (
+    sql: string,
+  ) => Effect.Effect<ReadonlyArray<Record<string, unknown>>, EngineError>
+  readonly execute: (sql: string) => Effect.Effect<void, EngineError>
+  /**
+   * Набор стейтментов одной транзакцией движка, откат при любой ошибке.
+   * Примитив адаптера, а не BEGIN/COMMIT через execute: на пуле соединений
+   * (Postgres) отдельные вызовы разъехались бы по разным соединениям.
+   */
+  readonly transaction: (
+    statements: ReadonlyArray<string>,
+  ) => Effect.Effect<void, EngineError>
+  /** Имена и типы колонок запроса без его выполнения (контракт схемы, SPEC §3.2). */
+  readonly describe: (sql: string) => Effect.Effect<ReadonlyArray<EngineColumn>, EngineError>
+  /**
+   * Канонический вид SELECT-запроса для fingerprint (SPEC §4, §9.2):
+   * парсинг родным парсером движка, нормализация, детерминированная
+   * сериализация. Переформатирование текста не меняет результат.
+   */
+  readonly canonicalize: (sql: string) => Effect.Effect<string, EngineError | SqlParseError>
+}
+
+export class EngineAdapter extends Context.Service<EngineAdapter, Engine>()(
+  "efmesh/EngineAdapter",
+) {}

package/src/engine/duckdb.ts

@@ -0,0 +1,117 @@
+import { DuckDBInstance } from "@duckdb/node-api"
+import { Effect, Layer, Semaphore } from "effect"
+import type { Engine, EngineColumn } from "./adapter.ts"
+import { EngineAdapter, EngineError, SqlParseError } from "./adapter.ts"
+
+/**
+ * AST от json_serialize_sql содержит позиции токенов (query_location) —
+ * единственное, чем отличаются одинаковые по смыслу, но по-разному
+ * отформатированные запросы. Вычищаем — остаётся формат-инвариантное ядро.
+ */
+const stripLocations = (value: unknown): unknown => {
+  if (Array.isArray(value)) return value.map(stripLocations)
+  if (value !== null && typeof value === "object") {
+    const out: Record<string, unknown> = {}
+    for (const [key, inner] of Object.entries(value)) {
+      if (key === "query_location") continue
+      out[key] = stripLocations(inner)
+    }
+    return out
+  }
+  return value
+}
+
+export interface DuckDBEngineOptions {
+  /** Путь к файлу базы; по умолчанию in-memory. */
+  readonly path?: string
+}
+
+export const DuckDBEngineLive = (
+  options?: DuckDBEngineOptions,
+): Layer.Layer<EngineAdapter, EngineError> =>
+  Layer.effect(
+    EngineAdapter,
+    Effect.gen(function* () {
+      const path = options?.path ?? ":memory:"
+      const { connection } = yield* Effect.acquireRelease(
+        Effect.tryPromise({
+          try: async () => {
+            const instance = await DuckDBInstance.create(path)
+            const connection = await instance.connect()
+            return { instance, connection }
+          },
+          catch: (cause) => new EngineError({ sql: `<connect ${path}>`, cause }),
+        }),
+        ({ connection, instance }) =>
+          Effect.sync(() => {
+            connection.closeSync()
+            instance.closeSync()
+          }),
+      )
+
+      const run = (sqlText: string) =>
+        Effect.tryPromise({
+          try: () => connection.run(sqlText),
+          catch: (cause) => new EngineError({ sql: sqlText, cause }),
+        })
+
+      const query: Engine["query"] = (sqlText) =>
+        run(sqlText).pipe(
+          Effect.flatMap((result) =>
+            Effect.tryPromise({
+              try: () => result.getRowObjects(),
+              catch: (cause) => new EngineError({ sql: sqlText, cause }),
+            }),
+          ),
+        )
+
+      // одно соединение: параллельные транзакции сериализуются семафором,
+      // чтобы фибры не перемежали чужие BEGIN/COMMIT
+      const transactionLock = yield* Semaphore.make(1)
+
+      const service: Engine = {
+        dialect: "duckdb",
+        query,
+        execute: (sqlText) => Effect.asVoid(run(sqlText)),
+        transaction: (statements) =>
+          transactionLock.withPermits(1)(
+            Effect.asVoid(run("BEGIN")).pipe(
+              Effect.andThen(
+                Effect.forEach(statements, (statement) => run(statement), { discard: true }),
+              ),
+              Effect.andThen(Effect.asVoid(run("COMMIT"))),
+              Effect.onError(() => Effect.asVoid(run("ROLLBACK")).pipe(Effect.ignore)),
+            ),
+          ),
+        describe: (sqlText) =>
+          query(`DESCRIBE (${sqlText})`).pipe(
+            Effect.map((rows): ReadonlyArray<EngineColumn> =>
+              rows.map((row) => ({
+                name: String(row["column_name"]),
+                type: String(row["column_type"]),
+              })),
+            ),
+          ),
+        canonicalize: (sqlText) =>
+          query(
+            `SELECT json_serialize_sql('${sqlText.replaceAll(`'`, `''`)}') AS ast`,
+          ).pipe(
+            Effect.flatMap((rows) => {
+              const ast = JSON.parse(String(rows[0]?.["ast"])) as {
+                readonly error: boolean
+                readonly error_message?: string
+              }
+              // ошибка парсинга приходит содержимым JSON, не исключением
+              if (ast.error) {
+                return new SqlParseError({
+                  sql: sqlText,
+                  message: ast.error_message ?? "parse error",
+                })
+              }
+              return Effect.succeed(JSON.stringify(stripLocations(ast)))
+            }),
+          ),
+      }
+      return service
+    }),
+  )

package/src/engine/postgres.ts

@@ -0,0 +1,119 @@
+import { SQL } from "bun"
+import { Effect, Layer } from "effect"
+import { parse } from "libpg-query"
+import type { Engine, EngineColumn } from "./adapter.ts"
+import { EngineAdapter, EngineError, SqlParseError } from "./adapter.ts"
+
+/**
+ * Postgres-адаптер (SPEC §9.1, F3) поверх встроенного клиента Bun (`Bun.SQL`):
+ * пул соединений из коробки — транзакция закрепляется за одним соединением
+ * через sql.begin, остальные запросы свободно распределяются по пулу,
+ * что и даёт честный параллелизм бэкфилла (SPEC §5.3).
+ *
+ * Канонизация — libpg_query (WASM-сборка парсера самого Postgres, SPEC §9.2):
+ * дерево разбора с вычищенными позициями токенов формат-инвариантно,
+ * как и json_serialize_sql у DuckDB.
+ */
+
+/** Позиции токенов (location) — единственная формат-зависимость дерева libpg_query. */
+const stripLocations = (value: unknown): unknown => {
+  if (Array.isArray(value)) return value.map(stripLocations)
+  if (value !== null && typeof value === "object") {
+    const out: Record<string, unknown> = {}
+    for (const [key, inner] of Object.entries(value)) {
+      if (key === "location") continue
+      out[key] = stripLocations(inner)
+    }
+    return out
+  }
+  return value
+}
+
+/**
+ * Канонизация Postgres-SQL — чистая (libpg_query, сервер не нужен);
+ * вынесена из Layer, чтобы golden-тесты могли заморозить канон
+ * независимо от пула (SPEC §4: канонизация = контракт fingerprint).
+ */
+export const canonicalizePostgresSql = (
+  sqlText: string,
+): Effect.Effect<string, SqlParseError> => {
+  // $start/$end канонического рендера — не синтаксис Postgres;
+  // детерминированная замена на $1/$2 сохраняет стабильность fingerprint
+  const parameterized = sqlText.replace(/\$start\b/g, "$1").replace(/\$end\b/g, "$2")
+  return Effect.tryPromise({
+    try: () => parse(parameterized),
+    catch: (cause) =>
+      new SqlParseError({
+        sql: sqlText,
+        message: cause instanceof Error ? cause.message : String(cause),
+      }),
+  }).pipe(Effect.map((tree) => JSON.stringify(stripLocations(tree))))
+}
+
+export interface PostgresEngineOptions {
+  /** postgres://… или unix-сокет через ?host=/путь. */
+  readonly url: string
+  /** Размер пула соединений; по умолчанию 8. */
+  readonly max?: number
+}
+
+export const PostgresEngineLive = (
+  options: PostgresEngineOptions,
+): Layer.Layer<EngineAdapter, EngineError> =>
+  Layer.effect(
+    EngineAdapter,
+    Effect.gen(function* () {
+      const sql = yield* Effect.acquireRelease(
+        Effect.try({
+          try: () => new SQL({ url: options.url, max: options.max ?? 8 }),
+          catch: (cause) => new EngineError({ sql: `<connect ${options.url}>`, cause }),
+        }),
+        (pool) => Effect.promise(() => pool.end()).pipe(Effect.ignore),
+      )
+
+      const query: Engine["query"] = (sqlText) =>
+        Effect.tryPromise({
+          try: async () => (await sql.unsafe(sqlText)) as ReadonlyArray<Record<string, unknown>>,
+          catch: (cause) => new EngineError({ sql: sqlText, cause }),
+        })
+
+      const service: Engine = {
+        dialect: "postgres",
+        query,
+        execute: (sqlText) => Effect.asVoid(query(sqlText)),
+        transaction: (statements) =>
+          Effect.tryPromise({
+            try: () =>
+              sql.begin(async (tx) => {
+                for (const statement of statements) await tx.unsafe(statement)
+              }),
+            catch: (cause) => new EngineError({ sql: statements.join(";\n"), cause }),
+          }).pipe(Effect.asVoid),
+        // DESCRIBE у Postgres нет: временный view на одном соединении
+        // (sql.begin) даёт имена и типы из каталога без выполнения запроса
+        describe: (sqlText) =>
+          Effect.tryPromise({
+            try: () =>
+              sql.begin(async (tx) => {
+                await tx.unsafe(`CREATE TEMP VIEW __efmesh_describe AS ${sqlText}`)
+                const rows = (await tx.unsafe(`
+                  SELECT a.attname AS name, format_type(a.atttypid, a.atttypmod) AS type
+                  FROM pg_attribute a
+                  WHERE a.attrelid = '__efmesh_describe'::regclass
+                    AND a.attnum > 0 AND NOT a.attisdropped
+                  ORDER BY a.attnum
+                `)) as ReadonlyArray<{ name: string; type: string }>
+                await tx.unsafe(`DROP VIEW __efmesh_describe`)
+                return rows
+              }),
+            catch: (cause) => new EngineError({ sql: sqlText, cause }),
+          }).pipe(
+            Effect.map((rows): ReadonlyArray<EngineColumn> =>
+              rows.map((row) => ({ name: row.name, type: row.type })),
+            ),
+          ),
+        canonicalize: canonicalizePostgresSql,
+      }
+      return service
+    }),
+  )

package/src/index.ts

@@ -0,0 +1,114 @@
+/**
+ * Публичное API efmesh (F6): осознанный whitelist вместо `export *` —
+ * всё, что экспортировано здесь, становится semver-обязательством пакета.
+ * Внутренности (naming, lock-хелперы, executor, planner, fingerprint-кухня)
+ * намеренно не экспортируются; юнит-тесты моделей — `efmesh/testing`.
+ */
+
+// — определение проекта: модели, виды, аудиты, конфиг —
+export {
+  defineExternal,
+  defineModel,
+  defineSeed,
+  defineSqlModel,
+  external,
+  kind,
+  columnNames,
+  parseModelName,
+  type AnyModel,
+  type ExternalConfig,
+  type ExternalSource,
+  type IncrementalByTimeRangeOptions,
+  type MaterializationTarget,
+  type Model,
+  type ModelConfig,
+  type ModelCtx,
+  type ModelKind,
+  type ModelName,
+} from "./core/model.ts"
+export { audit, type Audit, type AuditCtx } from "./core/audit.ts"
+export { defineConfig, type EfmeshConfig } from "./config.ts"
+export { discoverModels, DiscoveryConflictError, DiscoveryError } from "./discovery.ts"
+
+// — фасад и операции: обычные Effect'ы для встраивания (SPEC §10) —
+export { Efmesh } from "./efmesh.ts"
+export { run, daemon, Runner, RunBlockedByChangesError, type RunError, type RunOptions } from "./plan/run.ts"
+export { janitor, type JanitorOptions, type JanitorReport } from "./plan/janitor.ts"
+export {
+  auditEnvironment,
+  AuditTargetError,
+  EnvironmentAuditError,
+  type AuditRunReport,
+  type AuditRunResult,
+} from "./plan/audit-run.ts"
+export { diffEnvironments, type EnvDiff } from "./plan/diff.ts"
+export { formatLineage, lineage, LineageError, type LineageNode } from "./plan/lineage.ts"
+
+// — план и применение: типы результата и опций —
+export type {
+  ChangeCategory,
+  Plan,
+  PlanAction,
+  PlanOptions,
+} from "./plan/planner.ts"
+export { FingerprintVersionError, ForwardOnlyError, InvalidEnvironmentError } from "./plan/planner.ts"
+export type { AppliedPlan, ApplyError, ApplyOptions } from "./plan/executor.ts"
+export {
+  AttachNotConfiguredError,
+  DucklakeNotConfiguredError,
+  EngineFeatureError,
+  LakeNotConfiguredError,
+} from "./plan/executor.ts"
+export { AuditFailure } from "./core/audit.ts"
+export { SchemaMismatchError } from "./plan/contract.ts"
+export { LockHeldError, type LockOptions } from "./plan/lock.ts"
+export { FINGERPRINT_VERSION } from "./plan/fingerprint.ts"
+
+// — граф: составные ошибки загрузки проекта —
+export {
+  DagCycleError,
+  DuplicateModelError,
+  ModelDefinitionError,
+  SeedReadError,
+  UnknownDependencyError,
+} from "./core/errors.ts"
+export type { GraphError } from "./core/graph.ts"
+
+// — движки: слои и сервис (кастомные обёртки — например, для тестов) —
+export {
+  EngineAdapter,
+  EngineError,
+  SqlParseError,
+  type Dialect,
+  type Engine,
+  type EngineColumn,
+} from "./engine/adapter.ts"
+export { DuckDBEngineLive, type DuckDBEngineOptions } from "./engine/duckdb.ts"
+export {
+  canonicalizePostgresSql,
+  PostgresEngineLive,
+  type PostgresEngineOptions,
+} from "./engine/postgres.ts"
+
+// — state store: слои, миграции, записи —
+export {
+  StateStore,
+  StateError,
+  StateSchemaError,
+  STATE_VERSION,
+  type EnvironmentRecord,
+  type IntervalRecord,
+  type MigrationReport,
+  type PlanRecord,
+  type SnapshotRecord,
+  type StateStoreShape,
+} from "./state/store.ts"
+export { migrateSqliteState, SqliteStateLive, type SqliteStateOptions } from "./state/sqlite.ts"
+export {
+  migratePostgresState,
+  PostgresStateLive,
+  type PostgresStateOptions,
+} from "./state/postgres.ts"
+
+// — интервалы: границы для options.now и разбор отчётов —
+export { fromIso, toIso, type Interval, type IntervalUnit } from "./core/interval.ts"

package/src/init.ts

@@ -0,0 +1,88 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs"
+import * as NodePath from "node:path"
+import { Data, Effect } from "effect"
+
+/**
+ * `efmesh init` (SPEC §12): скаффолд минимального проекта — конфиг,
+ * пара моделей (seed + витрина с аудитом) и данные к ним. Ничего не
+ * перезаписывает: существующий efmesh.config.ts — честная ошибка.
+ */
+
+export class InitError extends Data.TaggedError("InitError")<{
+  readonly path: string
+  readonly reason: string
+}> {}
+
+const MODELS_TS = `import { Schema } from "effect"
+import { audit, defineModel, defineSeed, kind } from "@avytheone/efmesh"
+
+// seed: справочник из файла; содержимое входит в fingerprint —
+// правка CSV = новая версия и пересборка
+export const departments = defineSeed({
+  name: "ref.departments",
+  file: "seeds/departments.csv",
+  schema: Schema.Struct({ dept: Schema.String, floor: Schema.Number }),
+})
+
+// витрина: full-модель с контрактом схемы и blocking-аудитом
+export const floors = defineModel(
+  {
+    name: "mart.floors",
+    kind: kind.full(),
+    schema: Schema.Struct({ floor: Schema.Number, depts: Schema.Number }),
+    audits: [audit.notNull("floor")],
+  },
+  (ctx) => ctx.sql\`
+    SELECT floor, count(*)::INT AS depts
+    FROM \${ctx.ref(departments)}
+    GROUP BY floor
+  \`,
+)
+`
+
+const CONFIG_TS = `import { defineConfig } from "@avytheone/efmesh"
+import { departments, floors } from "./models.ts"
+
+export default defineConfig({
+  models: [departments, floors],
+  // engine: { url: "postgres://…" },  // вместо DuckDB-файла
+  // lake: { path: "lake" },           // для target: "parquet"
+})
+`
+
+const SEED_CSV = `dept,floor
+ОРИТ,3
+терапия,2
+хирургия,3
+`
+
+export const scaffold = (dir: string): Effect.Effect<ReadonlyArray<string>, InitError> =>
+  Effect.gen(function* () {
+    const root = NodePath.resolve(dir)
+    const files: ReadonlyArray<readonly [string, string]> = [
+      ["efmesh.config.ts", CONFIG_TS],
+      ["models.ts", MODELS_TS],
+      ["seeds/departments.csv", SEED_CSV],
+    ]
+    for (const [relative] of files) {
+      if (existsSync(NodePath.join(root, relative))) {
+        return yield* new InitError({
+          path: NodePath.join(root, relative),
+          reason: "файл уже существует — init ничего не перезаписывает",
+        })
+      }
+    }
+    return yield* Effect.try({
+      try: () => {
+        const created: Array<string> = []
+        for (const [relative, content] of files) {
+          const path = NodePath.join(root, relative)
+          mkdirSync(NodePath.dirname(path), { recursive: true })
+          writeFileSync(path, content)
+          created.push(relative)
+        }
+        return created
+      },
+      catch: (cause) => new InitError({ path: root, reason: String(cause) }),
+    })
+  })