yesilcam-studios 0.1.0

package/README.md

@@ -0,0 +1,18 @@
+# yesilcam-studios
+
+Yeşilçam Studios from your terminal (`yesilcam`) and from Claude (`yesilcam-mcp`). Same account, same token wallet as https://yesilcamstudios.com/app/.
+
+```bash
+npm install -g yesilcam-studios
+yesilcam login                 # email + password, token saved to ~/.config/yesilcam/config.json (0600)
+yesilcam balance
+yesilcam image "a lighthouse at dusk, 35mm film" --tier standard --out lighthouse.png
+yesilcam video --from 1234 --duration 5 --wait
+yesilcam tryon --garment 88 --person 77 --out look.png
+yesilcam maket analyze plan.dxf      # local, free
+yesilcam maket save plan.dxf --title "Villa"
+yesilcam pricing
+```
+
+Claude (MCP): `yesilcam mcp` prints the config snippet. Claude Code: `claude mcp add yesilcam -e YESILCAM_TOKEN=<token> -- yesilcam-mcp`.
+Get a token with `yesilcam login --json`, or set `YESILCAM_TOKEN` in the environment.

package/bin/yesilcam-mcp.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { startStdio } from '../src/mcp.js'
+startStdio().catch((e) => { console.error(e); process.exit(1) })

package/bin/yesilcam.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from '../src/cli.js'
+main(process.argv)

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "yesilcam-studios",
+  "version": "0.1.0",
+  "description": "Yeşilçam Studios CLI and MCP server: AI film, fashion try-on and Maket from your terminal or from Claude.",
+  "license": "UNLICENSED",
+  "type": "module",
+  "bin": { "yesilcam": "bin/yesilcam.js", "yesilcam-mcp": "bin/yesilcam-mcp.js" },
+  "files": ["bin", "src", "README.md"],
+  "engines": { "node": ">=18" },
+  "scripts": { "test": "vitest run", "pack": "npm pack" },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.1",
+    "commander": "^15.0.0",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": { "vitest": "^2.1.8" }
+}

package/src/cli.js

@@ -0,0 +1,120 @@
+import { Command } from 'commander'
+import { readFileSync, writeFileSync } from 'node:fs'
+import { basename, extname } from 'node:path'
+import { createInterface } from 'node:readline/promises'
+import { stdin as input, stdout as output } from 'node:process'
+import { login, makeClient, ApiError } from './client.js'
+import { readConfig, writeConfig, clearConfig, getUserToken, CONFIG_FILE } from './config.js'
+import { imageJob, videoJob, tryonJob, waitForJob, describeJob, TIERS, ASPECTS } from './jobs.js'
+import { analyzePlanText } from './maket/analyze.js'
+import { SITE_URL } from './constants.js'
+
+const out = (program, data, human) => { if (program.opts().json) console.log(JSON.stringify(data, null, 2)); else console.log(human ?? JSON.stringify(data, null, 2)) }
+const fmtInt = (n) => Number(n).toLocaleString('en-US')
+const client = () => { const t = getUserToken(); if (!t) { console.error('Not logged in. Run: yesilcam login'); process.exit(2) } return makeClient(t) }
+const MIME = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp', '.mp4': 'video/mp4', '.mp3': 'audio/mpeg', '.wav': 'audio/wav' }
+
+async function download(url, file) {
+  const res = await fetch(url); if (!res.ok) throw new Error(`download failed (${res.status})`)
+  writeFileSync(file, Buffer.from(await res.arrayBuffer())); return file
+}
+
+async function runJob(program, c, payload, opts) {
+  const r = await c.createJob(payload)
+  const jobId = r?.job_id || r?.id || r?.job?.id
+  if (!jobId) { out(program, r); return }
+  if (!opts.wait) { out(program, { job_id: String(jobId), status: 'queued' }, `Job ${jobId} queued. Check: yesilcam jobs status ${jobId} --wait`); return }
+  const job = await waitForJob(c, jobId, { onTick: (j) => { if (!program.opts().json && j) process.stderr.write(`\r${j.status}${j.render_progress ? ` ${j.render_progress}%` : ''}   `) } })
+  if (!program.opts().json) process.stderr.write('\n')
+  const d = describeJob(job)
+  if (opts.out && d?.result?.url) { await download(d.result.url, opts.out); d.saved = opts.out }
+  out(program, d, d.result ? `Done: ${d.result.url}${d.saved ? `\nSaved: ${d.saved}` : ''}` : `Job ${d.id}: ${d.status}${d.error ? ` (${d.error})` : ''}`)
+}
+
+export function buildProgram() {
+  const program = new Command()
+  program.name('yesilcam').description('Yeşilçam Studios: AI film, fashion try-on and Maket from your terminal.').version('0.1.0')
+    .option('--json', 'machine-readable output')
+
+  program.command('login').description('Sign in with your Yeşilçam Studios account')
+    .option('--email <email>').option('--password <password>').option('--token <userToken>', 'use an existing user token')
+    .action(async (o) => {
+      if (o.token) { writeConfig({ ...readConfig(), token: o.token }); out(program, { ok: true }, `Token saved to ${CONFIG_FILE}`); return }
+      let { email, password } = o
+      if (!email || !password) {
+        const rl = createInterface({ input, output })
+        email = email || await rl.question('Email: ')
+        password = password || await rl.question('Password: ')
+        rl.close()
+      }
+      const r = await login(email.trim(), password)
+      writeConfig({ token: r.token, user: r.user })
+      out(program, { ok: true, user: r.user }, `Signed in as ${r.user.name} ${r.user.lastname} <${r.user.email}>. Token saved to ${CONFIG_FILE}`)
+    })
+  program.command('logout').description('Remove the saved token').action(() => { clearConfig(); out(program, { ok: true }, 'Signed out.') })
+  program.command('whoami').description('Account and plan').action(async () => { const r = await client().me(); out(program, r, `${r.name} ${r.lastname} · plan: ${r.subscriptionPackageType || 'social-hive'}`) })
+  program.command('balance').description('Token balance').action(async () => { const r = await client().balance(); out(program, r, `${fmtInt(r.balance)} tokens`) })
+  program.command('pricing').description('Production costs (tokens) and token packs').action(async () => {
+    const c = client(); const [ops, packs] = await Promise.all([c.modulePricing(), c.tokenPackages()])
+    const rows = ops.filter((r) => ['ai-studio', 'fashion-tryon'].includes(r.module_key) && String(r.status ?? '1') === '1').map((r) => ({ module: r.module_key, operation: r.operation_key, tokens: Number(r.base_cost_tokens), free_per_month: Number(r.monthly_free_limit || 0) })).sort((a, b) => a.tokens - b.tokens)
+    const pk = packs.map((p) => ({ id: p.id, title: p.title, tokens: Number(p.token_amount), bonus_percent: Number(p.bonus_percentage), usd: Number(p.price_usd), usd_without_plan: p.price_usd_standard != null ? Number(p.price_usd_standard) : null, try: Number(p.price_tr), try_without_plan: p.price_tr_standard != null ? Number(p.price_tr_standard) : null }))
+    out(program, { operations: rows, packs: pk }, [...rows.map((r) => `${r.module.padEnd(14)} ${r.operation.padEnd(24)} ${fmtInt(r.tokens).padStart(10)} tokens${r.free_per_month ? `  (${r.free_per_month} free/month)` : ''}`), '', ...pk.map((p) => `${p.title.padEnd(14)} ${fmtInt(p.tokens).padStart(10)} tokens  $${p.usd} with plan / $${p.usd_without_plan ?? p.usd} without${p.bonus_percent ? `  +${p.bonus_percent}% bonus` : ''}`)].join('\n'))
+  })
+
+  const assets = program.command('assets').description('Your library (images, videos)')
+  assets.command('list').option('--kind <kind>', 'image|video').option('--limit <n>', '', '40').action(async (o) => {
+    const r = await client().assets({ kind: o.kind, limit: Number(o.limit) })
+    const list = r?.assets || r?.items || r || []
+    out(program, list, list.map((a) => `${String(a.id).padEnd(8)} ${String(a.kind).padEnd(6)} ${a.label || ''}  ${a.spaces_url || ''}`).join('\n') || 'No assets.')
+  })
+  assets.command('upload <file>').option('--kind <kind>', 'image|video|audio').option('--label <label>').action(async (file, o) => {
+    const ext = extname(file).toLowerCase(); const mime = MIME[ext] || 'application/octet-stream'
+    const kind = o.kind || (mime.startsWith('video') ? 'video' : mime.startsWith('audio') ? 'audio' : 'image')
+    const b64 = `data:${mime};base64,${readFileSync(file).toString('base64')}`
+    const r = await client().uploadAsset(b64, kind, o.label || basename(file))
+    out(program, r, `Uploaded asset ${r?.asset_id || r?.id || ''} ${r?.url || r?.spaces_url || ''}`)
+  })
+
+  const jobs = program.command('jobs').description('Generation jobs')
+  jobs.command('list').option('--limit <n>', '', '20').action(async (o) => { const r = await client().jobs({ limit: Number(o.limit) }); const list = r?.jobs || []; out(program, list, list.map((j) => `${String(j.id).padEnd(8)} ${String(j.job_type).padEnd(16)} ${String(j.status).padEnd(11)} ${j.quality_tier || ''}`).join('\n') || 'No jobs.') })
+  jobs.command('status <id>').option('--wait').option('--out <file>').action(async (id, o) => {
+    const c = client(); const job = o.wait ? await waitForJob(c, id) : (await c.jobStatus(Number(id))).job
+    const d = describeJob(job); if (o.out && d?.result?.url) { await download(d.result.url, o.out); d.saved = o.out }
+    out(program, d, `${d.id} ${d.type} ${d.status}${d.result ? ` ${d.result.url}` : ''}${d.saved ? `\nSaved: ${d.saved}` : ''}`)
+  })
+
+  program.command('image <prompt>').description('Generate an image (text2image)')
+    .option('--tier <tier>', TIERS.join('|'), 'draft').option('--aspect <ratio>', ASPECTS.join('|'), '16:9').option('--framing <f>', 'waist_up|waist_down|full_body')
+    .option('--wait', 'wait for the result').option('--out <file>', 'download result (implies --wait)')
+    .action(async (prompt, o) => runJob(program, client(), imageJob({ prompt, tier: o.tier, aspect: o.aspect, framing: o.framing }), { wait: o.wait || Boolean(o.out), out: o.out }))
+  program.command('video [prompt]').description('Generate a video (text2video, or image2video with --from)')
+    .option('--from <assetId>', 'source image asset id').option('--tier <tier>', TIERS.join('|'), 'draft').option('--aspect <ratio>', '', '16:9').option('--duration <s>').option('--resolution <r>', '480p|720p|1080p').option('--audio', 'generate audio')
+    .option('--wait').option('--out <file>')
+    .action(async (prompt = '', o) => runJob(program, client(), videoJob({ prompt, tier: o.tier, aspect: o.aspect, sourceAssetId: o.from, duration: o.duration, resolution: o.resolution, generateAudio: o.audio }), { wait: o.wait || Boolean(o.out), out: o.out }))
+  program.command('tryon').description('Fashion try-on: garment on a person or character')
+    .requiredOption('--garment <assetId>').option('--person <assetId>').option('--character <id>').option('--prompt <text>', 'style note').option('--wait').option('--out <file>')
+    .action(async (o) => { if (!o.person && !o.character) { console.error('--person <assetId> or --character <id> is required'); process.exit(2) } return runJob(program, client(), tryonJob({ garmentAssetId: o.garment, personAssetId: o.person, characterId: o.character, prompt: o.prompt }), { wait: o.wait || Boolean(o.out), out: o.out }) })
+  program.command('characters').description('List your characters').action(async () => { const r = await client().characters(); const list = r?.characters || r || []; out(program, list, list.map((c) => `${String(c.id).padEnd(8)} ${c.name || ''}`).join('\n') || 'No characters.') })
+
+  const maket = program.command('maket').description('Floor plan → 3D (Maket)')
+  maket.command('analyze <file>').description('Analyze a DXF/JSON plan locally (free)').action((file) => { const a = analyzePlanText(readFileSync(file, 'utf8'), basename(file)); out(program, a, `${a.name}: ${a.stats.wallCount} walls, ${a.stats.doorCount} doors, ${a.stats.windowCount} windows, ${a.stats.roomCount} rooms, gross ${a.stats.grossArea?.toFixed?.(1)} m² (${a.units.name}${a.units.guessed ? ', guessed' : ''})\nlayers: ${a.layers.map((l) => `${l.name}=${l.role}`).join(', ')}`) })
+  maket.command('list').description('Saved Maket projects').action(async () => { const r = await client().maketList(); out(program, r.items, r.items.map((p) => `${String(p.id).padEnd(6)} ${p.title}  ${p.source_kind}  ${new Date(p.updated_date_time * 1000).toISOString().slice(0, 10)}`).join('\n') || 'No projects.') })
+  maket.command('save <file>').description('Save a plan as a Maket project').option('--title <title>').action(async (file, o) => {
+    const text = readFileSync(file, 'utf8'); const a = analyzePlanText(text, basename(file))
+    const r = await client().maketCreate({ title: o.title || basename(file, extname(file)), source_kind: a.source_kind, source_text: text, settings: { overrides: {}, wallHeight: 2.9 }, stats: a.stats })
+    out(program, r, `Saved project ${r.id}. Open it at ${SITE_URL}/app/maket`)
+  })
+  maket.command('get <id>').description('Download a project’s plan').option('--out <file>').action(async (id, o) => { const r = await client().maketGet(Number(id)); const p = r.project; const file = o.out || `${p.title || 'maket'}.${p.source_kind === 'json' ? 'json' : 'dxf'}`; writeFileSync(file, p.source_text); out(program, { id: p.id, title: p.title, saved: file }, `Saved: ${file}`) })
+  maket.command('delete <id>').action(async (id) => { await client().maketDelete(Number(id)); out(program, { ok: true }, 'Deleted.') })
+
+  program.command('mcp').description('Print the Claude MCP configuration snippet').action(() => {
+    console.log(JSON.stringify({ mcpServers: { yesilcam: { command: 'yesilcam-mcp', env: { YESILCAM_TOKEN: '<your token: yesilcam login --json>' } } } }, null, 2))
+  })
+  return program
+}
+
+export async function main(argv) {
+  const program = buildProgram()
+  try { await program.parseAsync(argv) }
+  catch (e) { if (e instanceof ApiError || e?.message) { console.error(`Error: ${e.message}`); process.exit(1) } throw e }
+}

package/src/client.js

@@ -0,0 +1,54 @@
+import { API_URL, APP_KEY, APP_SECRET, REGISTRATION_SOURCE } from './constants.js'
+
+const base = API_URL.replace(/\/+$/, '') + '/'
+let appTokenCache = null
+
+export class ApiError extends Error { constructor(message, data) { super(message); this.data = data } }
+
+async function post(path, body, bearer, fetchImpl = globalThis.fetch) {
+  const headers = { 'Content-Type': 'application/json' }
+  if (bearer) headers.Authorization = `Bearer ${bearer}`
+  const res = await fetchImpl(base + path, { method: 'POST', headers, body: JSON.stringify(body || {}) })
+  const data = await res.json().catch(() => null)
+  if (!data || data.status !== true) throw new ApiError((data && (data.message || data?.result?.error)) || `request_failed (${res.status})`, data)
+  return data.result
+}
+
+export async function getAppToken(fetchImpl) {
+  if (appTokenCache) return appTokenCache
+  const r = await post('get-token', { key: APP_KEY, secret: APP_SECRET }, '', fetchImpl)
+  if (!r?.token) throw new ApiError('app_token_missing')
+  appTokenCache = r.token
+  return appTokenCache
+}
+
+/** E-posta + şifre → kullanıcı token'ı ve profil. */
+export async function login(email, password, fetchImpl) {
+  const app = await getAppToken(fetchImpl)
+  const r = await post('flow/user-login', { credential: email, password }, app, fetchImpl)
+  if (!r?.token || !r?.id) throw new ApiError('invalid_login_response')
+  return { token: r.token, user: { id: String(r.id), name: r.name || '', lastname: r.lastname || '', email: r.email || '' } }
+}
+
+export function makeClient(userToken, fetchImpl) {
+  if (!userToken) throw new ApiError('not_logged_in')
+  const flow = (name, body) => post(`flow/${name}`, body, userToken, fetchImpl)
+  return {
+    flow,
+    balance: () => flow('get-token-balance'),
+    me: () => flow('get-user-subscription-infos'),
+    modulePricing: () => flow('get-all-module-pricing'),
+    tokenPackages: () => flow('get-token-packages'),
+    routes: () => flow('aistudio-list-routes'),
+    assets: (p = {}) => flow('aistudio-asset-list', p),
+    uploadAsset: (fileBase64, kind = 'image', label = '') => flow('aistudio-upload-asset', { file_base64: fileBase64, kind, label }),
+    createJob: (p) => flow('aistudio-create-job', p),
+    jobStatus: (jobId) => flow('aistudio-job-status', { job_id: jobId }),
+    jobs: (p = {}) => flow('aistudio-job-list', p),
+    characters: () => flow('aistudio-character-list'),
+    maketList: () => flow('maket-list-projects'),
+    maketGet: (projectId) => flow('maket-get-project', { projectId }),
+    maketCreate: (p) => flow('maket-create-project', p),
+    maketDelete: (projectId) => flow('maket-delete-project', { projectId }),
+  }
+}

package/src/config.js

@@ -0,0 +1,18 @@
+import { mkdirSync, readFileSync, writeFileSync, existsSync, unlinkSync, chmodSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+export const CONFIG_DIR = process.env.YESILCAM_CONFIG_DIR || join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'yesilcam')
+export const CONFIG_FILE = join(CONFIG_DIR, 'config.json')
+
+export function readConfig() {
+  try { return JSON.parse(readFileSync(CONFIG_FILE, 'utf8')) } catch { return {} }
+}
+export function writeConfig(cfg) {
+  mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 })
+  writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2) + '\n', { mode: 0o600 })
+  try { chmodSync(CONFIG_FILE, 0o600) } catch {}
+}
+export function clearConfig() { if (existsSync(CONFIG_FILE)) unlinkSync(CONFIG_FILE) }
+/** Öncelik: YESILCAM_TOKEN env > config dosyası. */
+export function getUserToken() { return process.env.YESILCAM_TOKEN || readConfig().token || '' }

package/src/constants.js

@@ -0,0 +1,6 @@
+// Uygulama anahtarı: web uygulamasıyla aynı (get-token). Kullanıcı token'ı ayrı alınır ve diske yazılır.
+export const API_URL = process.env.YESILCAM_API_URL || 'https://prod.apiollon.com/'
+export const APP_KEY = process.env.YESILCAM_APP_KEY || 'F0RRDrlPigAYTmOSweyhBmo6aYZOLpTA8qGCGQe2wkmDHJYBF9'
+export const APP_SECRET = process.env.YESILCAM_APP_SECRET || 'anHHiSHfgOZ5zJKxWGJPO2PPNdIgL2HwdgUchEuC7bh5BLU'
+export const REGISTRATION_SOURCE = 'yesilcam-web'
+export const SITE_URL = 'https://yesilcamstudios.com'

package/src/jobs.js

@@ -0,0 +1,45 @@
+// İş oluşturma ve bekleme. Sözleşme: aistudio_jobs.status ∈ queued|processing|succeeded|failed.
+export const TIERS = ['draft', 'standard', 'cinema', 'cinemapro']
+export const ASPECTS = ['1:1', '16:9', '9:16', '3:4', '4:3']
+
+export function imageJob({ prompt, tier = 'draft', aspect = '16:9', framing }) {
+  const p = { job_type: 'text2image', prompt, quality_tier: tier, aspect_ratio: aspect }
+  if (framing) p.framing = framing
+  return p
+}
+export function videoJob({ prompt = '', tier = 'draft', aspect = '16:9', sourceAssetId, duration, resolution, generateAudio }) {
+  const p = { job_type: sourceAssetId ? 'image2video' : 'text2video', prompt, quality_tier: tier, aspect_ratio: aspect }
+  if (sourceAssetId) p.source_asset_id = Number(sourceAssetId)
+  if (duration) p.duration = Number(duration)
+  if (resolution) p.resolution = resolution
+  if (generateAudio) p.generate_audio = true
+  return p
+}
+export function tryonJob({ garmentAssetId, personAssetId, characterId, prompt = '' }) {
+  const p = { job_type: 'tryon', garment_asset_id: Number(garmentAssetId), prompt, quality_tier: 'standard' }
+  if (characterId) p.character_id = Number(characterId)
+  else if (personAssetId) p.source_asset_id = Number(personAssetId)
+  return p
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+const isDone = (s) => ['succeeded', 'failed', 'cancelled', 'refunded'].includes(String(s))
+
+/** İş bitene kadar bekler (varsayılan 4 sn aralık, 20 dk). onTick(job) ilerleme için. */
+export async function waitForJob(client, jobId, { intervalMs = 4000, timeoutMs = 20 * 60 * 1000, onTick, sleepImpl = sleep } = {}) {
+  const started = Date.now()
+  for (;;) {
+    const r = await client.jobStatus(Number(jobId))
+    const job = r?.job
+    onTick?.(job)
+    if (job && isDone(job.status)) return job
+    if (Date.now() - started > timeoutMs) throw new Error('job_wait_timeout')
+    await sleepImpl(intervalMs)
+  }
+}
+export function describeJob(job) {
+  if (!job) return null
+  return { id: String(job.id), type: job.job_type, status: job.status, tier: job.quality_tier, progress: job.render_progress != null ? Number(job.render_progress) : null,
+    tokens_charged: job.tokens_charged != null ? Number(job.tokens_charged) : null, error: job.error_code || null,
+    result: job.result_asset ? { asset_id: String(job.result_asset.id), kind: job.result_asset.kind, url: job.result_asset.spaces_url, thumb: job.result_asset.thumb_url } : null }
+}

package/src/maket/analyze.js

@@ -0,0 +1,16 @@
+// Maket yerel analiz: DXF/JSON → duvar/kapı/pencere/mahal istatistikleri (ağ yok, ücretsiz).
+import { modelFromDxfText, modelFromJsonPlan } from './plan/pipeline.js'
+import { attachOpenings } from './plan/geometry.js'
+import { DEMO_PLANS } from './demo/plans.js'
+
+export { DEMO_PLANS }
+export function analyzePlanText(text, name = 'plan', overrides = {}) {
+  const isJson = /\.json$/i.test(name) || /^\s*[{[]/.test(text)
+  const res = isJson ? modelFromJsonPlan(JSON.parse(text), { overrides }) : modelFromDxfText(text, { overrides })
+  const model = attachOpenings(res.model)
+  return {
+    name, source_kind: isJson ? 'json' : 'dxf', units: res.units,
+    layers: res.layers.map((l) => ({ name: l.name, role: l.role, count: l.count })),
+    stats: model.stats, rooms: model.rooms.map((r) => ({ name: r.name, area: r.area })),
+  }
+}

package/src/maket/demo/dxfWriter.js

@@ -0,0 +1,46 @@
+// PlanModel'i (metre) gerçekçi bir ASCII DXF'e yazar: duvarlar çift çizgi + uç kapakları,
+// kapılar ARC, pencereler LINE, mahaller kapalı LWPOLYLINE, adlar TEXT. Birim: cm ($INSUNITS 5).
+const K = 100; // m → cm
+const f = (v) => (v * K).toFixed(2);
+
+export function writeDxf(model, { name = 'MAKET' } = {}) {
+  const L = [];
+  const pair = (c, v) => L.push(String(c), String(v));
+  pair(0, 'SECTION'); pair(2, 'HEADER'); pair(9, '$INSUNITS'); pair(70, 5); pair(9, '$ACADVER'); pair(1, 'AC1015'); pair(0, 'ENDSEC');
+  pair(0, 'SECTION'); pair(2, 'TABLES'); pair(0, 'TABLE'); pair(2, 'LAYER');
+  for (const [ln, col] of [['A-WALL', 7], ['A-DOOR', 30], ['A-GLAZ', 4], ['A-AREA', 8], ['A-ANNO-TEXT', 2], ['A-FURN', 9], ['A-DIMS', 1]]) {
+    pair(0, 'LAYER'); pair(2, ln); pair(70, 0); pair(62, col); pair(6, 'CONTINUOUS');
+  }
+  pair(0, 'ENDTAB'); pair(0, 'ENDSEC');
+  pair(0, 'SECTION'); pair(2, 'ENTITIES');
+  const line = (layer, a, b) => { pair(0, 'LINE'); pair(8, layer); pair(10, f(a[0])); pair(20, f(a[1])); pair(30, 0); pair(11, f(b[0])); pair(21, f(b[1])); pair(31, 0); };
+
+  for (const w of model.walls) {
+    const dx = w.b[0] - w.a[0], dy = w.b[1] - w.a[1]; const len = Math.hypot(dx, dy) || 1;
+    const nx = (-dy / len) * (w.thickness / 2), ny = (dx / len) * (w.thickness / 2);
+    const a1 = [w.a[0] + nx, w.a[1] + ny], b1 = [w.b[0] + nx, w.b[1] + ny];
+    const a2 = [w.a[0] - nx, w.a[1] - ny], b2 = [w.b[0] - nx, w.b[1] - ny];
+    line('A-WALL', a1, b1); line('A-WALL', a2, b2); line('A-WALL', a1, a2); line('A-WALL', b1, b2);
+  }
+  for (const p of model.wallPolys || []) {
+    pair(0, 'LWPOLYLINE'); pair(8, 'A-WALL'); pair(90, p.points.length); pair(70, 1);
+    for (const q of p.points) { pair(10, f(q[0])); pair(20, f(q[1])); }
+  }
+  for (const w of model.windows) line('A-GLAZ', w.a, w.b);
+  for (const d of model.doors) {
+    const deg = (d.angle * 180) / Math.PI; const s = d.swing >= 0 ? deg : deg + d.swing; const e = d.swing >= 0 ? deg + d.swing : deg;
+    pair(0, 'ARC'); pair(8, 'A-DOOR'); pair(10, f(d.hinge[0])); pair(20, f(d.hinge[1])); pair(30, 0); pair(40, f(d.width)); pair(50, s.toFixed(2)); pair(51, e.toFixed(2));
+    const a = d.angle; line('A-DOOR', d.hinge, [d.hinge[0] + Math.cos(a) * d.width, d.hinge[1] + Math.sin(a) * d.width]);
+  }
+  for (const r of model.rooms) {
+    pair(0, 'LWPOLYLINE'); pair(8, 'A-AREA'); pair(90, r.points.length); pair(70, 1);
+    for (const q of r.points) { pair(10, f(q[0])); pair(20, f(q[1])); }
+    pair(0, 'TEXT'); pair(8, 'A-ANNO-TEXT'); pair(10, f(r.centroid[0])); pair(20, f(r.centroid[1])); pair(30, 0); pair(40, 25); pair(1, r.name);
+  }
+  for (const l of model.labels) { pair(0, 'TEXT'); pair(8, 'A-ANNO-TEXT'); pair(10, f(l.pos[0])); pair(20, f(l.pos[1])); pair(30, 0); pair(40, 25); pair(1, l.text); }
+  for (const d of model.decor) line('A-FURN', d.a, d.b);
+  // ölçü metni: yoksayılmalı
+  pair(0, 'TEXT'); pair(8, 'A-DIMS'); pair(10, f(model.bounds.cx)); pair(20, f(model.bounds.minY - 1)); pair(30, 0); pair(40, 20); pair(1, (model.bounds.w * 100).toFixed(0));
+  pair(0, 'ENDSEC'); pair(0, 'EOF');
+  return L.join('\n') + '\n';
+}

package/src/maket/demo/plans.js

@@ -0,0 +1,95 @@
+// Hazır planlar (metre). Aynı boru hattından geçer; DXF'e de yazılabilir.
+const R = (x0, y0, x1, y1) => [[x0, y0], [x1, y0], [x1, y1], [x0, y1]];
+
+export const DEMO_PLANS = [
+  {
+    id: 'bahceli-ev',
+    name: 'Bahçeli Ev',
+    subtitle: 'Tek katlı konut · 12 × 9 m',
+    units: 'm',
+    walls: [
+      { points: R(0, 0, 12, 9), closed: true },
+      { a: [6, 0], b: [6, 9] }, { a: [0, 5.5], b: [6, 5.5] }, { a: [6, 4], b: [12, 4] },
+      { a: [9, 4], b: [9, 9] }, { a: [9, 6.5], b: [12, 6.5] },
+    ],
+    doors: [
+      { hinge: [7, 9], angle: 0, width: 1.0, swing: -90 },
+      { hinge: [7, 4], angle: 0, width: 0.9, swing: -90 },
+      { hinge: [6, 4.2], angle: 90, width: 0.9, swing: 90 },
+      { hinge: [6, 6.5], angle: 90, width: 0.9, swing: 90 },
+      { hinge: [9, 4.8], angle: 90, width: 0.8, swing: -90 },
+      { hinge: [9, 7], angle: 90, width: 0.9, swing: -90 },
+    ],
+    windows: [
+      { a: [1.5, 0], b: [4.5, 0] }, { a: [7.5, 0], b: [10, 0] }, { a: [0, 1.5], b: [0, 3.5] }, { a: [0, 6], b: [0, 8] },
+      { a: [12, 1], b: [12, 3] }, { a: [12, 7], b: [12, 8.5] }, { a: [2, 9], b: [4, 9] }, { a: [10, 9], b: [11.5, 9] },
+      { a: [12, 5], b: [12, 6] },
+    ],
+    rooms: [
+      { name: 'Salon', points: R(0, 0, 6, 5.5) }, { name: 'Mutfak', points: R(6, 0, 12, 4) },
+      { name: 'Hol', points: R(6, 4, 9, 9) }, { name: 'Yatak Odası', points: R(0, 5.5, 6, 9) },
+      { name: 'Banyo', points: R(9, 4, 12, 6.5) }, { name: 'Çalışma Odası', points: R(9, 6.5, 12, 9) },
+    ],
+    decor: [
+      { points: R(6.1, 0.1, 11.9, 0.7), closed: true }, { points: R(11.3, 0.7, 11.9, 3.9), closed: true },
+      { points: R(0.3, 6.4, 2.3, 8.4), closed: true }, { points: R(0.5, 1.2, 0.9, 4.2), closed: true },
+      { points: R(0.9, 1.2, 4.2, 1.6), closed: true }, { points: R(9.2, 4.2, 10.0, 6.3), closed: true },
+      { points: R(9.2, 6.8, 11.6, 7.5), closed: true },
+    ],
+  },
+  {
+    id: 'ofis-kati',
+    name: 'Ofis Katı',
+    subtitle: 'Açık ofis + toplantı odaları · 20 × 12 m',
+    units: 'm',
+    walls: [
+      { points: R(0, 0, 20, 12), closed: true },
+      { a: [13, 0], b: [13, 8] }, { a: [13, 5], b: [20, 5] }, { a: [0, 8], b: [20, 8] },
+      { a: [5, 8], b: [5, 12] }, { a: [15, 8], b: [15, 12] },
+    ],
+    doors: [
+      { hinge: [13, 2], angle: 90, width: 0.9, swing: -90 }, { hinge: [13, 6], angle: 90, width: 0.9, swing: -90 },
+      { hinge: [9, 8], angle: 0, width: 1.0, swing: -90 }, { hinge: [5, 9.5], angle: 90, width: 0.9, swing: 90 },
+      { hinge: [15, 9.5], angle: 90, width: 0.9, swing: -90 }, { hinge: [10, 12], angle: 0, width: 1.4, swing: -90 },
+    ],
+    windows: [
+      { a: [2, 0], b: [6, 0] }, { a: [7, 0], b: [11, 0] }, { a: [14, 0], b: [19, 0] },
+      { a: [1, 12], b: [4, 12] }, { a: [16, 12], b: [19, 12] },
+      { a: [20, 1], b: [20, 4] }, { a: [20, 6], b: [20, 7.5] }, { a: [20, 9], b: [20, 11] },
+      { a: [0, 1], b: [0, 4] }, { a: [0, 5], b: [0, 7] }, { a: [0, 9], b: [0, 11] },
+    ],
+    rooms: [
+      { name: 'Açık Ofis', points: R(0, 0, 13, 8) }, { name: 'Toplantı A', points: R(13, 0, 20, 5) },
+      { name: 'Toplantı B', points: R(13, 5, 20, 8) }, { name: 'Mutfak', points: R(0, 8, 5, 12) },
+      { name: 'Koridor', points: R(5, 8, 15, 12) }, { name: 'Yönetici', points: R(15, 8, 20, 12) },
+    ],
+    decor: [
+      ...[1, 4, 7, 10].flatMap((x) => [2, 5].map((y) => ({ points: R(x, y, x + 1.6, y + 0.8), closed: true }))),
+      ...[1, 4, 7, 10].flatMap((x) => [3, 6].map((y) => ({ points: R(x, y, x + 1.6, y + 0.8), closed: true }))),
+      { points: R(14.5, 1.5, 18.5, 3.5), closed: true }, { points: R(14.5, 5.8, 18.5, 7.2), closed: true },
+      { points: R(16, 9, 18.5, 10), closed: true }, { points: R(0.2, 11.3, 4.8, 11.9), closed: true },
+    ],
+  },
+  {
+    id: 'studyo-daire',
+    name: 'Stüdyo Daire',
+    subtitle: 'Kompakt yaşam · 6 × 8 m',
+    units: 'm',
+    walls: [
+      { points: R(0, 0, 6, 8), closed: true }, { a: [0, 5.5], b: [6, 5.5] }, { a: [2.5, 5.5], b: [2.5, 8] },
+    ],
+    doors: [
+      { hinge: [4, 8], angle: 0, width: 1.0, swing: -90 }, { hinge: [2.5, 6.2], angle: 90, width: 0.8, swing: 90 },
+      { hinge: [3.5, 5.5], angle: 0, width: 0.9, swing: -90 },
+    ],
+    windows: [{ a: [1, 0], b: [5, 0] }, { a: [0, 1], b: [0, 3] }, { a: [6, 1.5], b: [6, 4] }],
+    rooms: [
+      { name: 'Yaşam Alanı', points: R(0, 0, 6, 5.5) }, { name: 'Banyo', points: R(0, 5.5, 2.5, 8) },
+      { name: 'Giriş Holü', points: R(2.5, 5.5, 6, 8) },
+    ],
+    decor: [
+      { points: R(0.3, 3.5, 2.3, 5.3), closed: true }, { points: R(3.5, 0.2, 5.8, 0.8), closed: true },
+      { points: R(0.4, 0.4, 2.2, 1.2), closed: true }, { points: R(0.2, 5.7, 1.0, 6.5), closed: true },
+    ],
+  },
+];

package/src/maket/dxf/parser.js

@@ -0,0 +1,243 @@
+// Minimal ASCII DXF ayrıştırıcı. Bağımlılık yok.
+// Çıktı: { header: {insunits}, layers: [{name,color}], blocks: {name: entities[]}, entities: [] }
+// Varlık türleri: LINE, LWPOLYLINE, POLYLINE(+VERTEX), CIRCLE, ARC, TEXT, MTEXT, INSERT
+
+export function parseDxf(text) {
+  const pairs = tokenize(text);
+  const out = { header: { insunits: null }, layers: [], blocks: {}, entities: [], warnings: [] };
+  let i = 0;
+  const n = pairs.length;
+
+  while (i < n) {
+    const [code, value] = pairs[i];
+    if (code === 0 && value === 'SECTION') {
+      const nameTok = pairs[i + 1];
+      const sectionName = nameTok && nameTok[0] === 2 ? nameTok[1] : '';
+      i += 2;
+      if (sectionName === 'HEADER') i = readHeader(pairs, i, out);
+      else if (sectionName === 'TABLES') i = readTables(pairs, i, out);
+      else if (sectionName === 'BLOCKS') i = readBlocks(pairs, i, out);
+      else if (sectionName === 'ENTITIES') {
+        const res = readEntities(pairs, i, 'ENDSEC');
+        out.entities = res.entities;
+        i = res.index;
+      } else i = skipSection(pairs, i);
+    } else if (code === 0 && value === 'EOF') break;
+    else i++;
+  }
+  return out;
+}
+
+function tokenize(text) {
+  const lines = text.split(/\r\n|\n|\r/);
+  const pairs = [];
+  for (let k = 0; k + 1 < lines.length; k += 2) {
+    const code = parseInt(lines[k].trim(), 10);
+    if (Number.isNaN(code)) continue;
+    pairs.push([code, lines[k + 1].trim()]);
+  }
+  return pairs;
+}
+
+function skipSection(pairs, i) {
+  while (i < pairs.length && !(pairs[i][0] === 0 && pairs[i][1] === 'ENDSEC')) i++;
+  return i + 1;
+}
+
+function readHeader(pairs, i, out) {
+  while (i < pairs.length) {
+    const [code, value] = pairs[i];
+    if (code === 0 && value === 'ENDSEC') return i + 1;
+    if (code === 9 && value === '$INSUNITS' && pairs[i + 1] && pairs[i + 1][0] === 70) {
+      out.header.insunits = parseInt(pairs[i + 1][1], 10);
+      i += 2;
+      continue;
+    }
+    i++;
+  }
+  return i;
+}
+
+function readTables(pairs, i, out) {
+  while (i < pairs.length) {
+    const [code, value] = pairs[i];
+    if (code === 0 && value === 'ENDSEC') return i + 1;
+    if (code === 0 && value === 'LAYER') {
+      const layer = { name: '0', color: 7 };
+      i++;
+      while (i < pairs.length && pairs[i][0] !== 0) {
+        if (pairs[i][0] === 2) layer.name = pairs[i][1];
+        if (pairs[i][0] === 62) layer.color = Math.abs(parseInt(pairs[i][1], 10));
+        i++;
+      }
+      out.layers.push(layer);
+      continue;
+    }
+    i++;
+  }
+  return i;
+}
+
+function readBlocks(pairs, i, out) {
+  while (i < pairs.length) {
+    const [code, value] = pairs[i];
+    if (code === 0 && value === 'ENDSEC') return i + 1;
+    if (code === 0 && value === 'BLOCK') {
+      let name = '';
+      let base = [0, 0];
+      i++;
+      while (i < pairs.length && pairs[i][0] !== 0) {
+        if (pairs[i][0] === 2) name = pairs[i][1];
+        if (pairs[i][0] === 10) base[0] = parseFloat(pairs[i][1]);
+        if (pairs[i][0] === 20) base[1] = parseFloat(pairs[i][1]);
+        i++;
+      }
+      const res = readEntities(pairs, i, 'ENDBLK');
+      out.blocks[name] = { name, base, entities: res.entities };
+      i = res.index;
+      // ENDBLK'in alt kodlarını atla
+      while (i < pairs.length && pairs[i][0] !== 0) i++;
+      continue;
+    }
+    i++;
+  }
+  return i;
+}
+
+const ENTITY_TYPES = new Set(['LINE', 'LWPOLYLINE', 'POLYLINE', 'CIRCLE', 'ARC', 'TEXT', 'MTEXT', 'INSERT']);
+
+function readEntities(pairs, i, terminator) {
+  const entities = [];
+  while (i < pairs.length) {
+    const [code, value] = pairs[i];
+    if (code === 0 && value === terminator) return { entities, index: i + 1 };
+    if (code === 0 && ENTITY_TYPES.has(value)) {
+      const res = readEntity(pairs, i);
+      if (res.entity) entities.push(res.entity);
+      i = res.index;
+      continue;
+    }
+    i++;
+  }
+  return { entities, index: i };
+}
+
+function readEntity(pairs, i) {
+  const type = pairs[i][1];
+  i++;
+  const raw = [];
+  while (i < pairs.length && pairs[i][0] !== 0) {
+    raw.push(pairs[i]);
+    i++;
+  }
+  const g = (code) => {
+    const p = raw.find((r) => r[0] === code);
+    return p ? p[1] : undefined;
+  };
+  const f = (code, def = 0) => {
+    const v = g(code);
+    return v === undefined ? def : parseFloat(v);
+  };
+  const layer = g(8) || '0';
+  let entity = null;
+
+  switch (type) {
+    case 'LINE':
+      entity = { type, layer, a: [f(10), f(20)], b: [f(11), f(21)] };
+      break;
+    case 'CIRCLE':
+      entity = { type, layer, center: [f(10), f(20)], r: f(40) };
+      break;
+    case 'ARC':
+      entity = { type, layer, center: [f(10), f(20)], r: f(40), start: f(50), end: f(51) };
+      break;
+    case 'TEXT':
+      entity = { type, layer, pos: [f(10), f(20)], height: f(40, 1), text: cleanText(g(1) || ''), rotation: f(50) };
+      break;
+    case 'MTEXT': {
+      const parts = raw.filter((r) => r[0] === 3).map((r) => r[1]).join('') + (g(1) || '');
+      entity = { type, layer, pos: [f(10), f(20)], height: f(40, 1), text: cleanText(parts), rotation: f(50) };
+      break;
+    }
+    case 'INSERT':
+      entity = {
+        type, layer, block: g(2) || '', pos: [f(10), f(20)],
+        scale: [f(41, 1), f(42, 1)], rotation: f(50),
+      };
+      break;
+    case 'LWPOLYLINE': {
+      const pts = [];
+      let cur = null;
+      for (const [c, v] of raw) {
+        if (c === 10) { cur = [parseFloat(v), 0]; pts.push(cur); }
+        else if (c === 20 && cur) cur[1] = parseFloat(v);
+      }
+      const flags = parseInt(g(70) || '0', 10);
+      entity = { type: 'POLYLINE', layer, points: pts, closed: (flags & 1) === 1 };
+      break;
+    }
+    case 'POLYLINE': {
+      const flags = parseInt(g(70) || '0', 10);
+      const pts = [];
+      // VERTEX'ler SEQEND'e kadar ayrı varlıklar olarak gelir
+      while (i < pairs.length && pairs[i][0] === 0 && pairs[i][1] === 'VERTEX') {
+        i++;
+        let x = 0, y = 0;
+        while (i < pairs.length && pairs[i][0] !== 0) {
+          if (pairs[i][0] === 10) x = parseFloat(pairs[i][1]);
+          if (pairs[i][0] === 20) y = parseFloat(pairs[i][1]);
+          i++;
+        }
+        pts.push([x, y]);
+      }
+      if (i < pairs.length && pairs[i][0] === 0 && pairs[i][1] === 'SEQEND') {
+        i++;
+        while (i < pairs.length && pairs[i][0] !== 0) i++;
+      }
+      entity = { type: 'POLYLINE', layer, points: pts, closed: (flags & 1) === 1 };
+      break;
+    }
+    default:
+      entity = null;
+  }
+  return { entity, index: i };
+}
+
+function cleanText(s) {
+  // MTEXT biçimlendirme kodlarını ayıkla: \P satır, {\fArial|b0;...}, \H1.2x; vb.
+  return s
+    .replace(/\\P/g, ' ')
+    .replace(/\\[A-Za-z][^;\\]*;/g, '')
+    .replace(/[{}]/g, '')
+    .replace(/%%[dDpPcC]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+// Blok referanslarını (INSERT) gerçek geometriye açar. Kapı/pencere blokları için konum korunur.
+export function explodeInserts(dxf, depth = 0) {
+  const result = [];
+  for (const e of dxf.entities) {
+    if (e.type !== 'INSERT') { result.push(e); continue; }
+    const block = dxf.blocks[e.block];
+    result.push(e); // referansı da koru (kapı tespiti için)
+    if (!block || depth > 3) continue;
+    const cos = Math.cos((e.rotation * Math.PI) / 180);
+    const sin = Math.sin((e.rotation * Math.PI) / 180);
+    const tf = (p) => {
+      const x = (p[0] - block.base[0]) * e.scale[0];
+      const y = (p[1] - block.base[1]) * e.scale[1];
+      return [e.pos[0] + x * cos - y * sin, e.pos[1] + x * sin + y * cos];
+    };
+    for (const be of block.entities) {
+      const layer = be.layer === '0' ? e.layer : be.layer;
+      const copy = { ...be, layer, fromBlock: e.block };
+      if (be.a) { copy.a = tf(be.a); copy.b = tf(be.b); }
+      if (be.center) { copy.center = tf(be.center); copy.r = be.r * Math.abs(e.scale[0]); if (be.type === 'ARC') { copy.start = be.start + e.rotation; copy.end = be.end + e.rotation; } }
+      if (be.points) copy.points = be.points.map(tf);
+      if (be.pos && be.type !== 'INSERT') copy.pos = tf(be.pos);
+      result.push(copy);
+    }
+  }
+  return result;
+}

package/src/maket/plan/classify.js

@@ -0,0 +1,74 @@
+// Katman adından eleman rolü çıkarır ve çizim birimini tahmin eder.
+
+export const ROLES = ['wall', 'door', 'window', 'text', 'room', 'decor', 'ignore'];
+
+export const ROLE_LABELS = {
+  wall: 'Duvar', door: 'Kapı', window: 'Pencere', text: 'Yazı', room: 'Mahal', decor: 'Dekor', ignore: 'Yoksay',
+};
+
+const RULES = [
+  ['ignore', /dim|olcu|ölçü|hatch|tarama|grid|aks|axis|defpoints|viewport|title|antet|frame|cerceve|çerçeve|xref|hidden/i],
+  ['window', /window|win\b|pencere|glaz|cam|fenster/i],
+  ['door', /door|kapi|kapı|tür|porte/i],
+  ['room', /room|mahal|space|zone|area|alan|oda|hacim/i],
+  ['text', /text|yazi|yazı|anno|label|etiket|note/i],
+  ['wall', /wall|duvar|mur|wand|a-wall|partition|bolme|bölme|struct|kolon|column/i],
+  ['decor', /furn|mobilya|esya|eşya|equip|sanit|vitr|stair|merdiven|kitchen|mutfak|banyo|bath|elec|mech|plumb|tesisat|site|peyzaj|landsc|tree|agac|ağaç|car|arac|araç|symbol|sembol/i],
+];
+
+export function roleForLayer(name) {
+  for (const [role, re] of RULES) if (re.test(name)) return role;
+  return null;
+}
+
+// Katman → rol haritası. Hiçbir katman duvar eşleşmezse en kalabalık çizgi katmanı duvar olur.
+export function buildLayerMap(entities, overrides = {}) {
+  const counts = new Map();
+  for (const e of entities) {
+    const c = counts.get(e.layer) || { total: 0, lines: 0, texts: 0, arcs: 0 };
+    c.total++;
+    if (e.type === 'LINE' || e.type === 'POLYLINE') c.lines++;
+    if (e.type === 'TEXT' || e.type === 'MTEXT') c.texts++;
+    if (e.type === 'ARC') c.arcs++;
+    counts.set(e.layer, c);
+  }
+  const map = {};
+  for (const [name, c] of counts) {
+    let role = overrides[name] || roleForLayer(name);
+    if (!role) role = c.texts > c.lines ? 'text' : null;
+    map[name] = role;
+  }
+  const hasWall = Object.values(map).includes('wall');
+  if (!hasWall) {
+    let best = null;
+    for (const [name, c] of counts) {
+      if (map[name] && map[name] !== 'decor') continue;
+      if (overrides[name]) continue;
+      if (!best || c.lines > counts.get(best).lines) best = name;
+    }
+    if (best) map[best] = 'wall';
+  }
+  for (const name of Object.keys(map)) if (!map[name]) map[name] = 'decor';
+  const layers = [...counts.entries()].map(([name, c]) => ({ name, count: c.total, role: map[name] }))
+    .sort((a, b) => b.count - a.count);
+  return { map, layers };
+}
+
+// DXF $INSUNITS kodları: 1 inç, 2 feet, 4 mm, 5 cm, 6 m
+export function unitsFromInsunits(code) {
+  switch (code) {
+    case 1: return { name: 'inç', toMeters: 0.0254 };
+    case 2: return { name: 'feet', toMeters: 0.3048 };
+    case 4: return { name: 'mm', toMeters: 0.001 };
+    case 5: return { name: 'cm', toMeters: 0.01 };
+    case 6: return { name: 'm', toMeters: 1 };
+    default: return null;
+  }
+}
+
+// Bina genişliği 3–300 m arasına düşecek birimi seç.
+export function guessUnits(extent) {
+  if (extent > 2000) return { name: 'mm', toMeters: 0.001, guessed: true };
+  if (extent > 200) return { name: 'cm', toMeters: 0.01, guessed: true };
+  return { name: 'm', toMeters: 1, guessed: true };
+}

package/src/maket/plan/fromJson.js

@@ -0,0 +1,41 @@
+// Maket JSON plan şeması → DXF benzeri varlık listesi (aynı boru hattından geçer).
+// {
+//   name, units: 'm'|'cm'|'mm',
+//   walls:   [{a:[x,y], b:[x,y]}] veya [{points:[[x,y]...], closed:true}]
+//   windows: [{a,b}], doors: [{hinge:[x,y], angle(deg), width, swing:90|-90}],
+//   rooms:   [{name, points:[[x,y]...]}], labels: [{pos:[x,y], text}], decor: [{a,b}|{points}]
+// }
+export const JSON_LAYERS = { wall: 'DUVAR', window: 'PENCERE', door: 'KAPI', room: 'MAHAL', text: 'YAZI', decor: 'DEKOR' };
+
+export function entitiesFromJson(plan) {
+  const ents = [];
+  const seg = (layer, o) => o.points
+    ? ents.push({ type: 'POLYLINE', layer, points: o.points, closed: !!o.closed })
+    : ents.push({ type: 'LINE', layer, a: o.a, b: o.b });
+  (plan.walls || []).forEach((w) => seg(JSON_LAYERS.wall, w));
+  (plan.windows || []).forEach((w) => seg(JSON_LAYERS.window, w));
+  (plan.decor || []).forEach((d) => seg(JSON_LAYERS.decor, d));
+  (plan.doors || []).forEach((d) => {
+    const swing = d.swing ?? 90;
+    const start = swing >= 0 ? d.angle : d.angle + swing;
+    const end = swing >= 0 ? d.angle + swing : d.angle;
+    ents.push({ type: 'ARC', layer: JSON_LAYERS.door, center: d.hinge, r: d.width, start, end });
+  });
+  (plan.rooms || []).forEach((r) => {
+    ents.push({ type: 'POLYLINE', layer: JSON_LAYERS.room, points: r.points, closed: true });
+    if (r.name) {
+      const c = centroid(r.points);
+      ents.push({ type: 'TEXT', layer: JSON_LAYERS.text, pos: c, text: r.name, height: 0.25 });
+    }
+  });
+  (plan.labels || []).forEach((l) => ents.push({ type: 'TEXT', layer: JSON_LAYERS.text, pos: l.pos, text: l.text, height: 0.25 }));
+  return ents;
+}
+
+export function unitsFromName(name) {
+  return { mm: { name: 'mm', toMeters: 0.001 }, cm: { name: 'cm', toMeters: 0.01 }, m: { name: 'm', toMeters: 1 } }[name || 'm'] || { name: 'm', toMeters: 1 };
+}
+
+function centroid(pts) {
+  let x = 0, y = 0; for (const p of pts) { x += p[0]; y += p[1]; } return [x / pts.length, y / pts.length];
+}

package/src/maket/plan/geometry.js

@@ -0,0 +1,347 @@
+// Varlıklar + katman rolleri + birim → PlanModel (metre cinsinden saf veri).
+// PlanModel:
+// { walls:[{a,b,thickness,len,angle}], wallPolys:[{points}], windows:[{a,b,len,angle}],
+//   doors:[{hinge:[x,y],angle,width,swing}], rooms:[{name,points,area,centroid}], labels:[{pos,text}],
+//   decor:[{a,b}], bounds:{minX,minY,maxX,maxY,w,d,cx,cy}, footprint:[[x,y]...], stats:{} }
+
+const DEG = Math.PI / 180;
+
+export function buildPlanModel(entities, layerMap, units, options = {}) {
+  const s = units.toMeters;
+  const defaultThickness = options.defaultThickness ?? 0.2;
+  const P = (p) => [p[0] * s, p[1] * s];
+  const role = (e) => layerMap[e.layer] || 'decor';
+
+  const rawWallSegs = [];
+  const wallPolys = [];
+  const windowSegs = [];
+  const doorCandidates = [];
+  const roomPolys = [];
+  const labels = [];
+  const decor = [];
+
+  const pushSegs = (arr, pts, closed) => {
+    for (let i = 0; i + 1 < pts.length; i++) arr.push({ a: pts[i], b: pts[i + 1] });
+    if (closed && pts.length > 2) arr.push({ a: pts[pts.length - 1], b: pts[0] });
+  };
+
+  for (const e of entities) {
+    const r = role(e);
+    if (r === 'ignore') continue;
+
+    if (e.type === 'TEXT' || e.type === 'MTEXT') {
+      if (!e.text || isDimensionText(e.text)) continue;
+      if (r === 'decor' && /^[\d.,\s]+$/.test(e.text)) continue;
+      labels.push({ pos: P(e.pos), text: e.text, layer: e.layer, size: (e.height || 1) * s });
+      continue;
+    }
+
+    if (e.type === 'LINE') {
+      const seg = { a: P(e.a), b: P(e.b) };
+      if (segLen(seg) < 1e-4) continue;
+      if (r === 'wall') rawWallSegs.push(seg);
+      else if (r === 'window') windowSegs.push(seg);
+      else if (r === 'door') doorCandidates.push({ kind: 'line', hinge: seg.a, width: segLen(seg), angle: segAngle(seg) });
+      else if (r === 'room') { /* mahal çizgileri kapalı çokgen değilse yoksay */ }
+      else decor.push(seg);
+      continue;
+    }
+
+    if (e.type === 'POLYLINE') {
+      const pts = e.points.map(P);
+      if (pts.length < 2) continue;
+      if (r === 'wall') {
+        if (e.closed && pts.length >= 3 && isThinPolygon(pts)) wallPolys.push({ points: dedupePts(pts) });
+        else pushSegs(rawWallSegs, pts, e.closed);
+      } else if (r === 'window') pushSegs(windowSegs, pts, e.closed);
+      else if (r === 'room') { if (e.closed && pts.length >= 3) roomPolys.push(dedupePts(pts)); }
+      else if (r === 'door') { if (pts.length >= 2) doorCandidates.push({ kind: 'line', hinge: pts[0], width: dist(pts[0], pts[pts.length - 1]), angle: angleOf(pts[0], pts[pts.length - 1]) }); }
+      else pushSegs(decor, pts, e.closed);
+      continue;
+    }
+
+    if (e.type === 'ARC') {
+      const c = P(e.center); const rr = e.r * s;
+      if (r === 'door' || (r === 'decor' && e.fromBlock && /door|kapi|kapı/i.test(e.fromBlock))) {
+        let sweep = e.end - e.start; while (sweep < 0) sweep += 360; while (sweep > 360) sweep -= 360;
+        if (rr > 0.5 && rr < 2.6 && sweep > 45 && sweep < 200) {
+          doorCandidates.push({ kind: 'arc', hinge: c, width: rr, angle: e.start * DEG, angleEnd: e.end * DEG, swing: sweep });
+        }
+      } else if (r !== 'room') decor.push(...arcToSegs(c, rr, e.start, e.end));
+      continue;
+    }
+
+    if (e.type === 'CIRCLE') {
+      if (r === 'wall') {
+        const c = P(e.center); const rr = e.r * s; // kolon
+        wallPolys.push({ points: circlePts(c, rr, 16), column: true });
+      } else if (r !== 'room' && r !== 'door') decor.push(...arcToSegs(P(e.center), e.r * s, 0, 360));
+      continue;
+    }
+
+    if (e.type === 'INSERT') {
+      if (r === 'door' || /door|kapi|kapı/i.test(e.block)) {
+        doorCandidates.push({ kind: 'insert', hinge: P(e.pos), width: 0.9 * Math.abs(e.scale[0] || 1) * (s === 1 ? 1 : 1), angle: e.rotation * DEG, weak: true });
+      } else if (r === 'window' || /window|pencere/i.test(e.block)) {
+        const w = 1.2; const a = e.rotation * DEG; const p = P(e.pos);
+        windowSegs.push({ a: p, b: [p[0] + Math.cos(a) * w, p[1] + Math.sin(a) * w], weak: true });
+      }
+      continue;
+    }
+  }
+
+  const { walls, caps } = mergeParallelWalls(rawWallSegs, { defaultThickness, maxThickness: options.maxThickness ?? 0.6 });
+  const windows = windowSegs.filter((w) => segLen(w) > 0.2).map((w) => ({ ...w, len: segLen(w), angle: segAngle(w) }));
+  const doors = dedupeDoors(doorCandidates);
+
+  const rooms = roomPolys.map((pts, i) => {
+    const area = Math.abs(polygonArea(pts));
+    const centroid = polygonCentroid(pts);
+    const inside = labels.find((l) => pointInPolygon(l.pos, pts));
+    return { name: inside ? inside.text : `Mahal ${i + 1}`, points: pts, area, centroid, labelled: !!inside };
+  });
+
+  const boundPts = [];
+  for (const w of walls) boundPts.push(w.a, w.b);
+  for (const p of wallPolys) boundPts.push(...p.points);
+  for (const w of windows) boundPts.push(w.a, w.b);
+  if (boundPts.length === 0) { for (const d of decor) boundPts.push(d.a, d.b); for (const l of labels) boundPts.push(l.pos); }
+  const bounds = boundsOf(boundPts);
+
+  const hullPts = [...boundPts, ...rooms.flatMap((r) => r.points)];
+  const footprint = hullPts.length >= 3 ? convexHull(hullPts) : [];
+  const footprintArea = footprint.length >= 3 ? Math.abs(polygonArea(footprint)) : 0;
+  const netArea = rooms.reduce((acc, r) => acc + r.area, 0);
+
+  const stats = {
+    wallCount: walls.length + wallPolys.length,
+    wallLength: walls.reduce((acc, w) => acc + w.len, 0),
+    doorCount: doors.length,
+    windowCount: windows.length,
+    roomCount: rooms.length,
+    labelCount: labels.length,
+    grossArea: footprintArea,
+    netArea,
+    perimeter: footprint.length >= 3 ? polygonPerimeter(footprint) : 0,
+    width: bounds.w,
+    depth: bounds.d,
+    capsRemoved: caps,
+    decorCount: decor.length,
+  };
+
+  return {
+    walls, wallPolys, windows, doors, rooms, labels: labels.filter((l) => !rooms.some((r) => r.labelled && r.name === l.text)),
+    decor: decor.slice(0, options.maxDecor ?? 6000), bounds, footprint, stats, units,
+  };
+}
+
+// ---------- Duvar birleştirme ----------
+// CAD'de duvarlar çoğu kez iki paralel çizgi olarak çizilir. Yakın paralel çiftler tek kalın duvara indirgenir;
+// uçlardaki kısa kapak çizgileri atılır.
+export function mergeParallelWalls(segs, { defaultThickness = 0.2, maxThickness = 0.6, minThickness = 0.04 } = {}) {
+  const n = segs.length;
+  const used = new Array(n).fill(false);
+  const walls = [];
+  const info = segs.map((sg) => ({ len: segLen(sg), ang: segAngle(sg), dir: unit(sg) }));
+
+  const candidates = [];
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const cross = Math.abs(info[i].dir[0] * info[j].dir[1] - info[i].dir[1] * info[j].dir[0]);
+      if (cross > Math.sin(3 * DEG)) continue;
+      const d = pointLineDist(segs[j].a, segs[i]);
+      const d2 = pointLineDist(segs[j].b, segs[i]);
+      if (Math.abs(d - d2) > 0.03) continue;
+      if (d < minThickness || d > maxThickness) continue;
+      const ti = [0, info[i].len];
+      const tj = [proj(segs[j].a, segs[i]), proj(segs[j].b, segs[i])].sort((x, y) => x - y);
+      const overlap = Math.min(ti[1], tj[1]) - Math.max(ti[0], tj[0]);
+      const shorter = Math.min(info[i].len, info[j].len);
+      if (overlap < Math.max(0.1, 0.3 * shorter)) continue;
+      candidates.push({ i, j, d, overlap, tj });
+    }
+  }
+  candidates.sort((x, y) => y.overlap - x.overlap || x.d - y.d);
+
+  for (const c of candidates) {
+    if (used[c.i] || used[c.j]) continue;
+    used[c.i] = used[c.j] = true;
+    const base = segs[c.i];
+    const dir = info[c.i].dir;
+    const tmin = Math.min(0, c.tj[0]);
+    const tmax = Math.max(info[c.i].len, c.tj[1]);
+    // merkez çizgisi: i çizgisinden j'ye doğru yarım kalınlık kaydır
+    const normal = [-dir[1], dir[0]];
+    const side = Math.sign((segs[c.j].a[0] - base.a[0]) * normal[0] + (segs[c.j].a[1] - base.a[1]) * normal[1]) || 1;
+    const off = [normal[0] * side * c.d / 2, normal[1] * side * c.d / 2];
+    const a = [base.a[0] + dir[0] * tmin + off[0], base.a[1] + dir[1] * tmin + off[1]];
+    const b = [base.a[0] + dir[0] * tmax + off[0], base.a[1] + dir[1] * tmax + off[1]];
+    walls.push(makeWall(a, b, c.d, true));
+  }
+
+  // kapaklar: paired çizgilerin uçlarına dokunan kısa serbest çizgiler
+  let caps = 0;
+  const pairedEnds = [];
+  for (let i = 0; i < n; i++) if (used[i]) pairedEnds.push(segs[i].a, segs[i].b);
+  const touches = (p) => pairedEnds.some((q) => dist(p, q) < 0.03);
+  for (let i = 0; i < n; i++) {
+    if (used[i]) continue;
+    const sg = segs[i];
+    if (walls.length && info[i].len <= maxThickness * 1.2 && touches(sg.a) && touches(sg.b)) { caps++; continue; }
+    walls.push(makeWall(sg.a, sg.b, defaultThickness, false));
+  }
+  return { walls, caps };
+}
+
+function makeWall(a, b, thickness, merged) {
+  return { a, b, thickness, len: dist(a, b), angle: angleOf(a, b), merged };
+}
+
+function dedupeDoors(cands) {
+  const strong = cands.filter((c) => !c.weak);
+  const pool = strong.length ? [...strong, ...cands.filter((c) => c.weak)] : cands;
+  const out = [];
+  for (const c of pool) {
+    if (out.some((d) => dist(d.hinge, c.hinge) < 0.35)) continue;
+    if (c.width < 0.5 || c.width > 2.6) continue;
+    out.push({ hinge: c.hinge, angle: c.angle, angleEnd: c.angleEnd, width: c.width, swing: c.swing ?? 90, kind: c.kind });
+  }
+  return out;
+}
+
+// ---------- Yardımcılar ----------
+export function dist(a, b) { return Math.hypot(b[0] - a[0], b[1] - a[1]); }
+export function segLen(s) { return dist(s.a, s.b); }
+export function angleOf(a, b) { return Math.atan2(b[1] - a[1], b[0] - a[0]); }
+export function segAngle(s) { return angleOf(s.a, s.b); }
+function unit(s) { const l = segLen(s) || 1; return [(s.b[0] - s.a[0]) / l, (s.b[1] - s.a[1]) / l]; }
+function proj(p, s) { const u = unit(s); return (p[0] - s.a[0]) * u[0] + (p[1] - s.a[1]) * u[1]; }
+function pointLineDist(p, s) { const u = unit(s); return Math.abs((p[0] - s.a[0]) * u[1] - (p[1] - s.a[1]) * u[0]); }
+
+function isDimensionText(t) { return /^[\d.,]+\s*(mm|cm|m|m²|m2)?$/i.test(t.trim()) || /^%%/.test(t); }
+
+function dedupePts(pts) {
+  const out = [];
+  for (const p of pts) if (!out.length || dist(out[out.length - 1], p) > 1e-6) out.push(p);
+  if (out.length > 1 && dist(out[0], out[out.length - 1]) < 1e-6) out.pop();
+  return out;
+}
+
+export function polygonArea(pts) {
+  let a = 0;
+  for (let i = 0; i < pts.length; i++) { const p = pts[i], q = pts[(i + 1) % pts.length]; a += p[0] * q[1] - q[0] * p[1]; }
+  return a / 2;
+}
+export function polygonPerimeter(pts) { let l = 0; for (let i = 0; i < pts.length; i++) l += dist(pts[i], pts[(i + 1) % pts.length]); return l; }
+export function polygonCentroid(pts) {
+  let cx = 0, cy = 0, a = 0;
+  for (let i = 0; i < pts.length; i++) {
+    const p = pts[i], q = pts[(i + 1) % pts.length]; const f = p[0] * q[1] - q[0] * p[1];
+    cx += (p[0] + q[0]) * f; cy += (p[1] + q[1]) * f; a += f;
+  }
+  if (Math.abs(a) < 1e-9) { const b = boundsOf(pts); return [b.cx, b.cy]; }
+  return [cx / (3 * a), cy / (3 * a)];
+}
+export function pointInPolygon(p, pts) {
+  let inside = false;
+  for (let i = 0, j = pts.length - 1; i < pts.length; j = i++) {
+    const a = pts[i], b = pts[j];
+    if ((a[1] > p[1]) !== (b[1] > p[1]) && p[0] < ((b[0] - a[0]) * (p[1] - a[1])) / (b[1] - a[1]) + a[0]) inside = !inside;
+  }
+  return inside;
+}
+// İnce çokgen: alan / (çevre/2) küçükse duvar kalınlığı gibi davranır (kalın çizilmiş duvar).
+export function isThinPolygon(pts) {
+  const area = Math.abs(polygonArea(pts)); const per = polygonPerimeter(pts);
+  if (per === 0) return false;
+  return area / (per / 2) < 0.6;
+}
+export function boundsOf(pts) {
+  if (!pts.length) return { minX: 0, minY: 0, maxX: 0, maxY: 0, w: 0, d: 0, cx: 0, cy: 0 };
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const p of pts) { if (p[0] < minX) minX = p[0]; if (p[0] > maxX) maxX = p[0]; if (p[1] < minY) minY = p[1]; if (p[1] > maxY) maxY = p[1]; }
+  return { minX, minY, maxX, maxY, w: maxX - minX, d: maxY - minY, cx: (minX + maxX) / 2, cy: (minY + maxY) / 2 };
+}
+export function convexHull(points) {
+  const pts = [...points].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  if (pts.length < 3) return pts;
+  const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+  const lower = []; for (const p of pts) { while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) lower.pop(); lower.push(p); }
+  const upper = []; for (let i = pts.length - 1; i >= 0; i--) { const p = pts[i]; while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) upper.pop(); upper.push(p); }
+  upper.pop(); lower.pop();
+  return lower.concat(upper);
+}
+function arcToSegs(c, r, startDeg, endDeg) {
+  let sweep = endDeg - startDeg; while (sweep <= 0) sweep += 360;
+  const steps = Math.max(4, Math.ceil(sweep / 15));
+  const out = [];
+  let prev = null;
+  for (let i = 0; i <= steps; i++) {
+    const a = (startDeg + (sweep * i) / steps) * DEG;
+    const p = [c[0] + Math.cos(a) * r, c[1] + Math.sin(a) * r];
+    if (prev) out.push({ a: prev, b: p });
+    prev = p;
+  }
+  return out;
+}
+function circlePts(c, r, n) { const out = []; for (let i = 0; i < n; i++) { const a = (i / n) * Math.PI * 2; out.push([c[0] + Math.cos(a) * r, c[1] + Math.sin(a) * r]); } return out; }
+
+// ---------- Boşluklar ----------
+// Pencere ve kapıları üzerinde durdukları duvara bağlar; her duvarı [solid|window|door] aralıklarına böler.
+// Eşleşmeyen pencere/kapı 'standalone' kalır (sahnede kendi başına çizilir).
+export function attachOpenings(model, { tolerance = 0.35 } = {}) {
+  const wallsOf = (seg) => {
+    let best = null;
+    for (let i = 0; i < model.walls.length; i++) {
+      const w = model.walls[i];
+      const u = [(w.b[0] - w.a[0]) / w.len, (w.b[1] - w.a[1]) / w.len];
+      const sd = dist(seg.a, seg.b) || 1;
+      const v = [(seg.b[0] - seg.a[0]) / sd, (seg.b[1] - seg.a[1]) / sd];
+      if (Math.abs(u[0] * v[1] - u[1] * v[0]) > Math.sin(4 * DEG)) continue;
+      const dA = Math.abs((seg.a[0] - w.a[0]) * u[1] - (seg.a[1] - w.a[1]) * u[0]);
+      if (dA > Math.max(tolerance, w.thickness)) continue;
+      const t0 = (seg.a[0] - w.a[0]) * u[0] + (seg.a[1] - w.a[1]) * u[1];
+      const t1 = (seg.b[0] - w.a[0]) * u[0] + (seg.b[1] - w.a[1]) * u[1];
+      const lo = Math.min(t0, t1), hi = Math.max(t0, t1);
+      const overlap = Math.min(hi, w.len) - Math.max(lo, 0);
+      if (overlap < 0.5 * (hi - lo)) continue;
+      if (!best || dA < best.dA) best = { i, dA, t0: Math.max(0, lo), t1: Math.min(w.len, hi) };
+    }
+    return best;
+  };
+
+  for (const w of model.walls) w.openings = [];
+  for (const win of model.windows) {
+    const hit = wallsOf(win);
+    win.wallIndex = hit ? hit.i : -1;
+    if (hit) model.walls[hit.i].openings.push({ type: 'window', t0: hit.t0, t1: hit.t1, ref: win });
+  }
+  for (const d of model.doors) {
+    // Yayın iki ucundan hangisi duvar üzerindeyse kapalı kanat yönü odur.
+    const tryAngle = (ang) => wallsOf({ a: d.hinge, b: [d.hinge[0] + Math.cos(ang) * d.width, d.hinge[1] + Math.sin(ang) * d.width] });
+    let hit = tryAngle(d.angle);
+    if (!hit && d.angleEnd !== undefined) {
+      hit = tryAngle(d.angleEnd);
+      if (hit) { d.angle = d.angleEnd; d.swing = -Math.abs(d.swing); }
+    }
+    d.wallIndex = hit ? hit.i : -1;
+    if (hit) model.walls[hit.i].openings.push({ type: 'door', t0: hit.t0, t1: hit.t1, ref: d });
+  }
+  for (const w of model.walls) w.segments = splitIntervals(w.len, w.openings);
+  return model;
+}
+
+export function splitIntervals(len, openings) {
+  const ops = [...openings].sort((a, b) => a.t0 - b.t0);
+  const out = [];
+  let cur = 0;
+  for (const o of ops) {
+    const t0 = Math.max(cur, o.t0), t1 = Math.min(len, o.t1);
+    if (t1 - t0 < 0.05) continue;
+    if (t0 - cur > 0.02) out.push({ type: 'solid', t0: cur, t1: t0 });
+    out.push({ type: o.type, t0, t1, ref: o.ref });
+    cur = t1;
+  }
+  if (len - cur > 0.02) out.push({ type: 'solid', t0: cur, t1: len });
+  return out;
+}

package/src/maket/plan/pipeline.js

@@ -0,0 +1,29 @@
+// Tek giriş noktası: DXF metni veya JSON planı → PlanModel + katman listesi.
+import { parseDxf, explodeInserts } from '../dxf/parser.js';
+import { buildLayerMap, unitsFromInsunits, guessUnits } from './classify.js';
+import { buildPlanModel, boundsOf } from './geometry.js';
+import { entitiesFromJson, unitsFromName } from './fromJson.js';
+
+export function modelFromDxfText(text, { overrides = {}, defaultThickness } = {}) {
+  const dxf = parseDxf(text);
+  const entities = explodeInserts(dxf);
+  if (!entities.length) throw new Error('DXF içinde çizilebilir varlık bulunamadı (LINE, LWPOLYLINE, ARC, TEXT...).');
+  const { map, layers } = buildLayerMap(entities, overrides);
+  let units = unitsFromInsunits(dxf.header.insunits);
+  if (!units) {
+    const pts = [];
+    for (const e of entities) { if (e.a) pts.push(e.a, e.b); if (e.points) pts.push(...e.points); }
+    const b = boundsOf(pts);
+    units = guessUnits(Math.max(b.w, b.d));
+  }
+  const model = buildPlanModel(entities, map, units, { defaultThickness });
+  return { model, layers, units, source: 'dxf' };
+}
+
+export function modelFromJsonPlan(plan, { overrides = {}, defaultThickness } = {}) {
+  const entities = entitiesFromJson(plan);
+  const { map, layers } = buildLayerMap(entities, overrides);
+  const units = unitsFromName(plan.units);
+  const model = buildPlanModel(entities, map, units, { defaultThickness });
+  return { model, layers, units, source: 'json' };
+}

package/src/mcp.js

@@ -0,0 +1,64 @@
+// Claude için MCP sunucusu (stdio). Araçlar CLI ile aynı istemciyi kullanır.
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { z } from 'zod'
+import { readFileSync } from 'node:fs'
+import { basename, extname } from 'node:path'
+import { makeClient } from './client.js'
+import { getUserToken } from './config.js'
+import { imageJob, videoJob, tryonJob, waitForJob, describeJob, TIERS, ASPECTS } from './jobs.js'
+import { analyzePlanText } from './maket/analyze.js'
+import { SITE_URL } from './constants.js'
+
+const text = (data) => ({ content: [{ type: 'text', text: typeof data === 'string' ? data : JSON.stringify(data, null, 2) }] })
+const fail = (e) => ({ isError: true, content: [{ type: 'text', text: `Error: ${e?.message || e}` }] })
+const MIME = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp', '.mp4': 'video/mp4', '.mp3': 'audio/mpeg', '.wav': 'audio/wav' }
+
+export function createServer({ client: injected } = {}) {
+  const server = new McpServer({ name: 'yesilcam', version: '0.1.0' })
+  const client = () => injected || makeClient(getUserToken())
+  const guarded = (fn) => async (args) => { try { return await fn(args) } catch (e) { return fail(e) } }
+
+  server.registerTool('yesilcam_balance', { description: 'Token balance of the signed-in Yeşilçam Studios account.', inputSchema: {} },
+    guarded(async () => text(await client().balance())))
+  server.registerTool('yesilcam_account', { description: 'Account name, email and subscription plan.', inputSchema: {} },
+    guarded(async () => text(await client().me())))
+  server.registerTool('yesilcam_pricing', { description: 'Production costs in tokens (Film Studio and Fashion Try-On operations) and token packs with prices.', inputSchema: {} },
+    guarded(async () => { const c = client(); const [ops, packs] = await Promise.all([c.modulePricing(), c.tokenPackages()]); return text({ operations: ops.filter((r) => ['ai-studio', 'fashion-tryon'].includes(r.module_key)).map((r) => ({ module: r.module_key, operation: r.operation_key, tokens: Number(r.base_cost_tokens), free_per_month: Number(r.monthly_free_limit || 0) })), packs }) }))
+  server.registerTool('yesilcam_list_assets', { description: 'List images/videos in the user library. Returns asset ids and URLs.', inputSchema: { kind: z.enum(['image', 'video']).optional(), limit: z.number().int().min(1).max(100).optional() } },
+    guarded(async ({ kind, limit }) => text(await client().assets({ kind, limit: limit || 40 }))))
+  server.registerTool('yesilcam_upload_asset', { description: 'Upload a local image/video/audio file to the library. Returns the asset id to use in other tools.', inputSchema: { path: z.string(), label: z.string().optional() } },
+    guarded(async ({ path, label }) => { const ext = extname(path).toLowerCase(); const mime = MIME[ext] || 'application/octet-stream'; const kind = mime.startsWith('video') ? 'video' : mime.startsWith('audio') ? 'audio' : 'image'; return text(await client().uploadAsset(`data:${mime};base64,${readFileSync(path).toString('base64')}`, kind, label || basename(path))) }))
+  server.registerTool('yesilcam_create_image', { description: 'Generate an image from a prompt (Film Studio). Costs tokens. Set wait=true to block until the result URL is ready.', inputSchema: { prompt: z.string().min(3), tier: z.enum(TIERS).optional(), aspect: z.enum(ASPECTS).optional(), framing: z.enum(['waist_up', 'waist_down', 'full_body']).optional(), wait: z.boolean().optional() } },
+    guarded(async ({ prompt, tier, aspect, framing, wait }) => run(client(), imageJob({ prompt, tier: tier || 'draft', aspect: aspect || '16:9', framing }), wait)))
+  server.registerTool('yesilcam_create_video', { description: 'Generate a video from a prompt (text2video) or animate an image asset (image2video, give source_asset_id). Costs tokens.', inputSchema: { prompt: z.string().optional(), source_asset_id: z.string().optional(), tier: z.enum(TIERS).optional(), aspect: z.enum(ASPECTS).optional(), duration: z.number().int().optional(), resolution: z.enum(['480p', '720p', '1080p']).optional(), generate_audio: z.boolean().optional(), wait: z.boolean().optional() } },
+    guarded(async (a) => run(client(), videoJob({ prompt: a.prompt || '', tier: a.tier || 'draft', aspect: a.aspect || '16:9', sourceAssetId: a.source_asset_id, duration: a.duration, resolution: a.resolution, generateAudio: a.generate_audio }), a.wait)))
+  server.registerTool('yesilcam_tryon', { description: 'Fashion Try-On: put a garment (image asset) on a person (image asset) or a saved character. Costs tokens.', inputSchema: { garment_asset_id: z.string(), person_asset_id: z.string().optional(), character_id: z.string().optional(), prompt: z.string().optional(), wait: z.boolean().optional() } },
+    guarded(async (a) => { if (!a.person_asset_id && !a.character_id) throw new Error('person_asset_id or character_id is required'); return run(client(), tryonJob({ garmentAssetId: a.garment_asset_id, personAssetId: a.person_asset_id, characterId: a.character_id, prompt: a.prompt }), a.wait) }))
+  server.registerTool('yesilcam_job_status', { description: 'Status and result URL of a generation job.', inputSchema: { job_id: z.string(), wait: z.boolean().optional() } },
+    guarded(async ({ job_id, wait }) => { const c = client(); const job = wait ? await waitForJob(c, job_id) : (await c.jobStatus(Number(job_id))).job; return text(describeJob(job)) }))
+  server.registerTool('yesilcam_list_jobs', { description: 'Recent generation jobs.', inputSchema: { limit: z.number().int().min(1).max(100).optional() } },
+    guarded(async ({ limit }) => text(await client().jobs({ limit: limit || 20 }))))
+  server.registerTool('yesilcam_list_characters', { description: 'Saved characters (for consistent faces across scenes).', inputSchema: {} },
+    guarded(async () => text(await client().characters())))
+  server.registerTool('yesilcam_maket_analyze', { description: 'Analyze a local DXF or JSON floor plan (Maket): walls, doors, windows, rooms, areas, layer roles. Free, runs locally.', inputSchema: { path: z.string() } },
+    guarded(async ({ path }) => text(analyzePlanText(readFileSync(path, 'utf8'), basename(path)))))
+  server.registerTool('yesilcam_maket_projects', { description: 'Saved Maket projects of the account.', inputSchema: {} },
+    guarded(async () => text(await client().maketList())))
+  server.registerTool('yesilcam_maket_save', { description: `Save a local floor plan as a Maket project; open it at ${SITE_URL}/app/maket.`, inputSchema: { path: z.string(), title: z.string().optional() } },
+    guarded(async ({ path, title }) => { const t = readFileSync(path, 'utf8'); const a = analyzePlanText(t, basename(path)); return text(await client().maketCreate({ title: title || basename(path, extname(path)), source_kind: a.source_kind, source_text: t, settings: { overrides: {}, wallHeight: 2.9 }, stats: a.stats })) }))
+  return server
+}
+
+async function run(c, payload, wait) {
+  const r = await c.createJob(payload)
+  const jobId = r?.job_id || r?.id || r?.job?.id
+  if (!jobId) return text(r)
+  if (!wait) return text({ job_id: String(jobId), status: 'queued', hint: 'Call yesilcam_job_status with wait=true to get the result.' })
+  return text(describeJob(await waitForJob(c, jobId)))
+}
+
+export async function startStdio() {
+  const server = createServer()
+  await server.connect(new StdioServerTransport())
+}