Tier 0 ($15-25/мес):  Playwright + OmniParser skip + Cerebras free→paid
                      + Gemini paid + Modal spot
                      → ~1-2k URLs/мес

Tier 1 ($50-100/мес): + Modal A10G keep-warm для OmniParser
                      → 5-10k URLs/мес

Tier 2 ($300-600/мес): + Hyperbrowser anti-bot + Supabase $25
                      → 50-100k URLs/мес

Tier 3 ($2-5k/мес):    + A100 LoRA + dedicated pgvector
                      → 500k+ URLs/мес

async function phase1(url: string): Promise<RawCapture> {
  const { ip } = await safeFetchGuard(url);  // SSRF + random pick from safe IPs
  const parsed = new URL(url);
 
  let browser;
  try {
    browser = await playwright.chromium.launch({
      args: [`--host-resolver-rules=MAP ${parsed.hostname} ${ip}`]
    });
    const page = await browser.newPage({
      userAgent: 'ARNOBot/1.0',
      viewport: { width: 1440, height: 900 }
    });
 
    const responses: NetworkResponse[] = [];
    page.on('response', r => responses.push(r));
 
    try {
      await page.goto(url, { waitUntil: 'networkidle', timeout: 30_000 });
    } catch (e) {
      if (isAntiBotSignal(e)) return phase1ViaHyperbrowser(url);
      throw new ExtractionError('navigation_failed', e);
    }
 
    const { ast: cssAST, errors: cssErrors } = await parseCSSGracefully(responses);
 
    return {
      dom: await page.content(),
      cssAST,
      cssParseErrors: cssErrors.length,
      cssInJsDetected: detectCssInJs(responses),
      computedStyles: await captureComputedStyles(page),
      sourceMaps: await tryExtractSourceMaps(responses),  // jackpot 30-50% сайтов
      framework: detectFramework(responses),
      jsBundle: await captureJsBundle(responses)
    };
  } finally {
    await browser?.close();  // P1 leak fix
  }
}
 
async function parseCSSGracefully(responses) {
  const errors: string[] = [];
  const cssTexts = responses.filter(r => r.contentType?.includes('css')).map(r => r.body);
  const asts = cssTexts.map(css => {
    try { return postcss.parse(css); }
    catch {
      return postcss.parse(css, { parser: safeParser, warn: msg => errors.push(msg) });
    }
  });
  return { ast: asts, errors };
}

function coverageGate(spec: PartialComponentSpec): 'pass' | 'enrich' {
  const filled = REQUIRED_FIELDS.filter(f =>
    spec[f] !== undefined && spec[f].confidence > 0.6
  );
  return (filled.length / REQUIRED_FIELDS.length) >= 0.90 ? 'pass' : 'enrich';
}

async function generateTSX(spec): Promise<GeneratedCode> {
  let raw: GeneratedCode;
  try {
    if (isAtomicLevel(spec)) raw = templateGenerate(spec);
    else raw = await cerebras.generate({ model: 'llama-3.1-70b', prompt: buildTsxPrompt(spec) });
  } catch {
    raw = await gemini.generate({ model: 'gemini-2.5-flash-lite', prompt: buildTsxPrompt(spec) });
  }
  raw.tsx = sanitizeTsx(raw.tsx).tsx;  // см § XI.8
  return raw;
}

function inferSampleProps(spec, visited = new Set(), depth = 0): { props, unknownTypes } {
  if (depth > 3) return { props: {}, unknownTypes: ['__max_depth__'] };
 
  const props: Record<string, any> = {};
  const unknownTypes: string[] = [];
 
  for (const [name, def] of Object.entries(spec.props)) {
    if (def.default !== undefined) { props[name] = def.default; continue; }
 
    // String literal union: '"primary" | "secondary"'
    const literals = (String(def.type)).match(/"([^"]+)"/g);
    if (literals) { props[name] = literals[0].replace(/"/g, ''); continue; }
 
    // Primitives
    const primitives = { string: name, number: 0, boolean: false,
                         ReactNode: 'Sample', function: () => {}, array: [] };
    if (def.type in primitives) { props[name] = primitives[def.type]; continue; }
 
    // TS union array → first
    if (Array.isArray(def.type)) { props[name] = def.type[0]; continue; }
 
    // Object recursive (cycle-safe)
    if (def.type?.fields) {
      const key = JSON.stringify(def.type);
      if (visited.has(key)) {
        props[name] = null;
        unknownTypes.push(`${name}__cycle__`);
        continue;
      }
      visited.add(key);
      const nested = inferSampleProps({ props: def.type.fields }, visited, depth + 1);
      props[name] = nested.props;
      continue;
    }
 
    // Unknown — placeholder + flag
    props[name] = null;
    unknownTypes.push(name);
  }
 
  return { props, unknownTypes };
}
 
// forwardRef detection + generic instantiation
const forwardRefMatch = tsx.match(/(?:React\.)?forwardRef<[^,>]+,\s*([^>]+)>/);
if (forwardRefMatch) spec.props = extractPropsFromType(forwardRefMatch[1]);
// Generic T → string substitution
for (const def of Object.values(spec.props)) {
  if (typeof def.type === 'string') def.type = def.type.replace(/\bT\b/g, 'string');
}

async function acceptanceGate(tsx, original, spec): Promise<TestResult> {
  // Test 1: TypeScript compiles
  const tsc = await typescript.compile(tsx);
  if (tsc.errors.length > 0) return { ok: false, reason: `tsc: ${tsc.errors[0].message}` };
 
  // Test 2: Renders без ErrorBoundary trigger
  const { props } = inferSampleProps(spec);
  const wrapped = wrapWithErrorBoundary(tsx);
  let rendered;
  try { rendered = await playwrightRender(wrapped, props); }
  catch (e) { return { ok: false, reason: `render: ${e.message}` }; }
 
  if (rendered.includes('data-render-error="true"')) {
    return { ok: false, reason: 'ErrorBoundary triggered', failedFields: ['props_inference'] };
  }
 
  // Test 3: Visually close
  const diff = await pixelmatch(rendered, original);
  if (diff > 0.30) {
    return { ok: false, reason: `visual diff ${diff.toFixed(2)}`,
             failedFields: identifyMismatchRegions(rendered, original) };
  }
 
  return { ok: true, sampleProps: props };
}

async function visionEnrich(spec, failedFields, screenshot) {
  // Tier 2+: OmniParser pre-filter (×5-20 token savings)
  // Tier 0-1: skip OmniParser, send full screenshot to Gemini VLM
  const targetRegions = await getTargetRegions(failedFields, screenshot);
 
  for (const field of failedFields) {
    try {
      const cropped = cropScreenshot(screenshot, targetRegions[field].bbox);
      const response = await gemini.vlm({
        model: 'gemini-2.5-flash-lite',
        image: cropped,
        prompt: `Extract ${field}. Context: ${JSON.stringify(spec.meta)}.`,
        timeout: 15_000
      });
      spec[field] = {
        value: response.value,
        source: 'vision',
        confidence: response.confidence,
        model_version: response.modelVersion ?? 'gemini-2.5-flash-lite-2026-02'
      };
    } catch (e) {
      // Partial failure: continue, не abort
      spec[field] = { value: null, source: 'vision', confidence: 0, error: e.message };
    }
  }
  return spec;
}

async function completenessCheck(component, captureMatrix): Promise<CompletenessReport> {
  const combinations = generateCombinations({
    themes: Object.keys(captureMatrix),
    viewports: [320, 768, 1024, 1440],
    states: detectAllStates(component)
  });
 
  const results = await Promise.all(combinations.map(async combo => {
    const original = captureMatrix[combo.theme][combo.viewport][combo.state];
    const generated = await renderGenerated(component.tsx, combo);
    const diff = await pixelmatch(original, generated, {
      ignoreText: true,    // юзер свой контент вставит
      ignoreImages: true
    });
    return { combo, diff, pass: diff < 0.15 };
  }));
 
  return {
    complete: results.filter(r => r.pass).length / results.length >= 0.90,
    coverage: results.filter(r => r.pass).length / results.length,
    failedCombos: results.filter(r => !r.pass).map(r => r.combo)
  };
}

async function uniquenessCheck(component): Promise<UniquenessResult> {
  try {
    const embedding = await dinov2.embedONNXCPU(component.screenshot);
    const neighbors = await pgvector.query({
      table: 'component_embeddings_visual',
      vector: embedding,
      limit: 5,
      distance: 'cosine'
    });
 
    if (neighbors.length === 0 || neighbors[0].distance > 0.4) {
      return { decision: 'new', auto: true };
    }
    return { decision: 'pending', neighbors };  // UI shows → юзер выбирает
  } catch (e) {
    return { decision: 'new', auto: true, flag: 'uniqueness_check_skipped' };
  }
}

const QUEUE_VOLUME = '/mnt/arno-queue';  // Modal Volume — persistent across restarts
 
async function integrate(component, userDecision, manifest): Promise<void> {
  const arnoId = uuidv7();
  const localPath = `${QUEUE_VOLUME}/${arnoId}/`;
 
  // 1. Persistent local storage (survives worker restart)
  await fs.writeFiles(localPath, component.files);
 
  // 2. Queue entry в local SQLite (на том же Volume)
  await queueDb.insert({
    arno_id: arnoId,
    user_id: user.id,
    local_path: localPath,
    target_b2_path: `staging/${user.id}/${arnoId}/`,
    created_at: now(),
    attempts: 0,
    status: 'pending'
  });
 
  // 3. DB record — serving from local until uploaded
  await db.components.create({
    arno_id: arnoId,
    user_id: user.id,
    status: 'queued',
    serving_from: 'local',
    manifest
  });
 
  // NB: Yjs init lazy — only on editor open (см openComponentEditor)
}
 
// Background uploader worker
async function b2UploaderWorker() {
  while (true) {
    const pending = await queueDb.where({
      status: 'pending',
      next_retry_at: lte(now())
    }).limit(10);
 
    for (const entry of pending) {
      try {
        await b2.uploadDir(entry.local_path, entry.target_b2_path);
        await queueDb.update(entry.id, { status: 'uploaded' });
        await db.components.update({ arno_id: entry.arno_id }, {
          status: 'staged',
          serving_from: 'b2'
        });
        await fs.rm(entry.local_path);
      } catch (e) {
        const backoff = [60, 300, 900, 3600][entry.attempts] ?? 3600;
        await queueDb.update(entry.id, {
          attempts: entry.attempts + 1,
          next_retry_at: now() + backoff * 1000
        });
        if (entry.attempts > 3) alert.send('B2 outage, queue depth growing');
      }
    }
    await sleep(60_000);
  }
}
 
// ARNO editor — Yjs lazy init
async function openComponentEditor(arnoId: string) {
  let yjsDoc = await yjs.getDocument(arnoId);
  if (!yjsDoc) {
    const component = await loadFromStaging(arnoId);  // local OR b2
    yjsDoc = await yjs.initialize(arnoId, component);
  }
  return yjsDoc;
}
 
// V2: юзер connects git, push from staging
async function pushStagedToGit(userId: string, githubToken: string) {
  const staged = await db.components.where({ user_id: userId, status: 'staged' });
  for (const c of staged) {
    const branch = `import/${sanitizeBranchName(c.name)}-${Date.now()}-${randomBytes(2).toString('hex')}`;
    await git.createBranch(user.repo, branch, githubToken);
    await git.commitFiles(user.repo, branch, await b2.fetch(c.staging_path));
    await git.createPR(user.repo, branch, { title: `Import: ${c.name}` });
    await db.components.update(c.id, { status: 'pushed' });
  }
}
 
function sanitizeBranchName(name: string): string {
  return name.toLowerCase()
    .replace(/[^a-z0-9-]/g, '-')
    .replace(/-+/g, '-')
    .slice(0, 60);  // GitHub branch ~250 limit, 60 + ts + rand4 = ~85
}

type ComponentSpec = {
  meta: {
    name: string;
    arno_id: string;           // UUIDv7 (timestamp-sortable)
    type: 'atomic' | 'molecule' | 'organism';
    origin_url: string;
    origin_selector: string;     // CSS path
    extraction_timestamp: ISO8601;  // КАНОНИЧЕСКИЙ timestamp
    extraction_mode: ExtractionMode;
  };
 
  props: {
    [name: string]: {
      type: TypeScriptType;
      required: boolean;
      default?: any;
      provenance: Provenance;
    }
  };
 
  variants: Array<{
    name: string;          // 'primary' | 'secondary' | etc
    when: Predicate;
    overrides: Partial<ComponentSpec>;
    provenance: Provenance;
  }>;
 
  states: {
    [name: string]: {
      // default | hover | focus | active | disabled | custom
      style_overrides: CSSProperties;
      attribute_overrides?: { [attr: string]: string };
      provenance: Provenance;
    }
  };
 
  tokens: {
    colors: { [name: string]: { value: string; provenance: Provenance } };
    spacing: { [name: string]: { value: string; provenance: Provenance } };
    typography: { [name: string]: TypographyToken & { provenance: Provenance } };
    shadows: { [name: string]: { value: string; provenance: Provenance } };
    radii: { [name: string]: { value: string; provenance: Provenance } };
    transitions: { [name: string]: { value: string; provenance: Provenance } };
  };
 
  responsive: {
    [breakpoint: number]: {
      style_overrides: CSSProperties;
      provenance: Provenance;
    }
  };
 
  accessibility: {
    aria: { [attr: string]: string };
    role: string;
    keyboard: KeyboardSpec;
    contrast_ratio_target: 4.5;          // WCAG AA
    contrast_ratio_actual?: number;
    provenance: Provenance;
  };
 
  composition?: {
    atoms: Array<{
      type: AtomType;       // A1-A8 (см url_import_atoms_a1_a8.md)
      instance_id: string;
      props_override: any;
    }>;
  };
};
 
const REQUIRED_FIELDS = [
  'meta.name', 'meta.type',
  'tokens.colors.primary',
  'states.default',
  'accessibility.role'
];

type Provenance = {
  source: 'source_map' | 'css_variable' | 'computed_style' | 'dom' | 'aria'
        | 'llm_inference' | 'vision';
  layer: 1 | 2 | 3 | 4 | 5 | 6 | 7;
  confidence: number;          // 0-1
  raw_value?: any;
  extracted_at: ISO8601;
  model_version?: string;      // REQUIRED if source in ['llm_inference', 'vision']
  model_canary_checksum?: string;  // daily-computed drift detection
};
 
function validateProvenance(p: Provenance) {
  if (['llm_inference', 'vision'].includes(p.source) && !p.model_version) {
    throw new ValidationError(`model_version required when source=${p.source}`);
  }
}
 
// Read-side migration для pre-v4 data
function readProvenance(raw): Provenance {
  if (['llm_inference', 'vision'].includes(raw.source) && !raw.model_version) {
    raw.model_version = 'legacy_pre_v4';
    metrics.increment('provenance.legacy_read');
  }
  return raw;
}
 
// Daily model canary cron — drift detection
async function dailyModelCanary() {
  const canary = 'Reply exactly: "arno-canary-2026"';
  const response = await gemini.generate({ contents: canary });
  const checksum = sha256(response.text);
 
  const prev = await db.modelCanaries.previous('gemini-2.5-flash-lite');
  if (prev && prev.checksum !== checksum) {
    alert.send('Model weights drifted без version change');
  }
  await db.modelCanaries.create({ model: 'gemini-2.5-flash-lite', checksum });
}

{
  "arno_id": "01923f8a-...-7b2c",
  "arno_version": "1.3",
  "version_number": 1,
  "parent_import_id": null,
  "imported_from": "https://example.com/products",
  "imported_at": "2026-05-22T10:30:00Z",
  "extraction_mode": "code+vision",
  "user_attestation": {
    "ownership_confirmed": true,
    "confirmed_at": "2026-05-22T10:29:55Z",
    "user_id": "uuid",
    "license_type": "owned",
    "domain_reputation_check": "passed"
  },
  "completeness": {
    "coverage": 0.94,
    "failed_combinations": [{ "theme": "dark", "viewport": 320, "state": "hover" }]
  },
  "provenance_summary": {
    "source_map_fields": 12,
    "dom_fields": 23,
    "vision_fields": 4,
    "llm_fields": 2,
    "model_versions_used": {
      "vision": "gemini-2.5-flash-lite-2026-02",
      "llm_inference": "gemini-2.5-flash-lite-2026-02"
    }
  },
  "uniqueness_decision": "new",
  "atoms": ["A1:Surface", "A2:Label", "A4:InteractionState"],
  "cost_actual_usd": 0.0024,
  "sanitization": {
    "rejected_expressions": [],
    "dangerous_attributes": 0,
    "sanitizer": "ts-morph-whitelist-3.0.0"
  },
  "css_parse_errors": 0,
  "sample_props_used": {
    "variant": "primary",
    "label": "Sample",
    "_unknown_types": []
  },
  "integration_status": "staged",
  "staging_path": "staging/user-uuid/01923f8a/.../",
  "serving_from": "b2"
}

async function mergeAtom(canonical: Atom, duplicate: Atom) {
  await db.transaction(async tx => {
    const dup = await tx.atoms.findOne(
      { id: duplicate.id },
      { lockMode: 'pessimistic_write' }
    );
    if (!dup || dup.merged_into) return;
    await tx.atoms.update({ id: duplicate.id }, {
      merged_into: canonical.id, merged_at: now()
    });
    await tx.componentAtomRefs.update(
      { atom_id: duplicate.id }, { atom_id: canonical.id }
    );
  });
}
// Reduces vector count ~30%, отодвигает Supabase paid tier breakpoint

const SEGMENT_PRIORITY = [
  'e-commerce',        // strongest signal /shop|store|cart|product/
  'dashboard-app',     // /app|dashboard|admin/
  'tech-blog',         // /blog|medium|substack/
  'news-media',        // /news|times|post/
  'marketing-landing'  // /landing|home|about/ — weakest, catch-all
];
 
function detectSegment(url: string): string {
  for (const segment of SEGMENT_PRIORITY) {
    if (SEGMENTS[segment].test(url)) return segment;
  }
  return 'other';
}
 
async function buildTrainingDataset() {
  const all = await db.shadowDataset.all();
  const bySegment = groupBy(all, e => detectSegment(e.url_hash));
  const maxPerSegment = Math.floor(all.length * 0.25);  // cap 25% per segment
  const balanced = [];
  for (const items of Object.values(bySegment)) {
    balanced.push(...sample(items, Math.min(items.length, maxPerSegment)));
  }
  return shuffle(balanced);
}

const BLOCKED_NETWORKS = [
  '0.0.0.0/8', '10.0.0.0/8', '127.0.0.0/8',
  '169.254.0.0/16', '172.16.0.0/12', '192.168.0.0/16',
  '::1/128', 'fc00::/7', 'fe80::/10'
];
 
async function safeFetchGuard(url: string): Promise<{ ip: string }> {
  const parsed = new URL(url);
  if (!['http:', 'https:'].includes(parsed.protocol)) throw new SSRFError('scheme');
 
  const ips = await dns.resolve(parsed.hostname);
  const safeIps = ips.filter(ip => !isInBlockedNetwork(ip));
  if (safeIps.length === 0) throw new SSRFError('no_safe_ips');
 
  await rateLimiter.check(userId, { free: '10/hour', paid: '100/hour' });
 
  // Random pick from safe IPs — aggregate behavior = load-balanced across extractions
  return { ip: safeIps[Math.floor(Math.random() * safeIps.length)] };
}

URL: [_______________________]

☑ Я владею правом на этот URL или у меня есть лицензия
   Лицензия: ⊙ Owned  ○ Licensed  ○ Public domain

⚠️ [для Tranco top 15k commercial sites — extra checkbox required]

[Принимая Terms of Service, вы соглашаетесь с использованием
 анонимизированных данных. См Privacy Policy.]

[Импортировать]

Privacy Settings
  ☑ Anonymous data contribution  (default ON)
  [Learn more] [Delete past contributions]

const commercialDomains = new BloomFilter(loadTrancoTop15k());  // buffer zone vs top 10k
 
function checkDomainReputation(url): 'normal' | 'requires_extra_confirmation' {
  return commercialDomains.has(new URL(url).hostname)
    ? 'requires_extra_confirmation' : 'normal';
}
 
// Daily cron rebuild Bloom from Tranco
async function refreshDomainReputation() {
  const trancoList = await fetch('https://tranco-list.eu/top-1m.csv.zip');
  const top15k = parseAndExtract(trancoList, 15000);
  const newBloom = BloomFilter.from(top15k, { errorRate: 0.01, size: 150_000 });
  await b2.upload('shared/tranco-bloom.bin', newBloom.serialize());
  await broadcast.send('reload-bloom-filter');
}

async function deleteUserData(userId: string) {
  try {
    // 1. B2 deletes (idempotent retry)
    await retry(async () => {
      await b2.deletePrefix(`staging/${userId}/`);
      await b2.deletePrefix(`shadow/${userId}/`);
      await b2.deletePrefix(`screenshots/${userId}/`);
    }, { attempts: 3, backoff: 'exponential' });
 
    // 2. Marker — B2 cleaned
    await db.gdprDeletions.create({
      user_id_hash: sha256(userId),
      b2_deleted_at: now()
    });
 
    // 3. DB cascade transaction
    await db.transaction(async tx => {
      await tx.components.where({ user_id: userId }).delete();
      await tx.shadowDataset.where({ user_id: userId }).delete();
      await yjs.deleteUserDocuments(userId);
      await tx.atomCatalog.where({ contributed_by: userId })
        .update({ contributed_by: null, provenance: 'anonymized' });
      await tx.componentEmbeddings.where({ user_id: userId }).delete();
      await tx.users.delete(userId);
    });
 
    await db.gdprDeletions.update(
      { user_id_hash: sha256(userId) },
      { completed_at: now() }
    );
  } catch (e) {
    await db.failedDeletions.create({ user_id_hash: sha256(userId), error: e.message });
    throw e;
  }
}
 
// Background sweeper для orphan B2 files
async function sweepOrphanB2Files() {
  const b2Prefixes = await b2.listTopLevelPrefixes();
  for (const prefix of b2Prefixes) {
    const userId = prefix.split('/')[1];
    if (!await db.users.exists(userId)) {
      await b2.deletePrefix(prefix);
    }
  }
}

async function checkHyperbrowserBudget() {
  const window = await metrics.window('hyperbrowser_usage', { minutes: 10 });
 
  // Per-domain check
  const byDomain = groupBy(window.events, e => new URL(e.url).hostname);
  for (const [domain, events] of Object.entries(byDomain)) {
    if (events.length / window.total > 0.20) {
      await domainRateLimit.set(domain, 0.1);
      await alert.send(`Domain ${domain} > 20% Hyperbrowser usage`);
    }
  }
 
  // Per-user check
  const byUser = groupBy(window.events, e => e.user_id);
  for (const [userId, events] of Object.entries(byUser)) {
    if (events.length / window.total > 0.10) {
      await userRateLimit.set(userId, 0.5);
    }
  }
 
  // Global only if true distributed attack
  if (window.unique_users > 100 && window.ratio > 0.15) {
    await globalRateLimit.set(0.5);
    await alert.pageOnCall('Distributed attack pattern');
  }
}
setInterval(checkHyperbrowserBudget, 60_000);

import { Project, Node, SyntaxKind } from 'ts-morph';
 
const ALLOWED_JSX_VALUE_KINDS = [
  SyntaxKind.StringLiteral, SyntaxKind.NumericLiteral,
  SyntaxKind.TrueKeyword, SyntaxKind.FalseKeyword, SyntaxKind.NullKeyword,
  SyntaxKind.PropertyAccessExpression,
  SyntaxKind.Identifier,
  SyntaxKind.ConditionalExpression,
  SyntaxKind.BinaryExpression,
  SyntaxKind.TemplateExpression,
  SyntaxKind.ArrowFunction,        // event handlers
  SyntaxKind.FunctionExpression
];
 
const DANGEROUS_CALLEES = [
  'fetch', 'eval', 'Function', 'setTimeout', 'setInterval',
  'XMLHttpRequest', 'window', 'document', 'globalThis', 'self'
];
 
function isCallExpressionSafe(node): boolean {
  const callee = node.getExpression();
  if (Node.isIdentifier(callee)) return !DANGEROUS_CALLEES.includes(callee.getText());
  if (Node.isPropertyAccessExpression(callee)) {
    return !DANGEROUS_CALLEES.includes(getRootIdentifier(callee));
  }
  return false;  // computed access (foo['fetch']) — blocked
}
 
function sanitizeTsx(tsx: string) {
  const project = new Project({ useInMemoryFileSystem: true });
  const sf = project.createSourceFile('temp.tsx', tsx);
  const report = { rejected_expressions: [], dangerous_attributes: 0 };
 
  sf.forEachDescendant(node => {
    if (Node.isJsxAttribute(node) && node.getName() === 'dangerouslySetInnerHTML') {
      node.remove();
      report.dangerous_attributes++;
    }
 
    if (Node.isJsxExpression(node)) {
      const expr = node.getExpression();
      if (!expr) return;
      const kind = expr.getKind();
      if (ALLOWED_JSX_VALUE_KINDS.includes(kind)) return;
      if (kind === SyntaxKind.CallExpression && isCallExpressionSafe(expr)) return;
 
      node.replaceWithText('{null}');
      report.rejected_expressions.push(expr.getKindName());
    }
  });
 
  return { tsx: sf.getFullText(), removed: report };
}

async function checkCostAnomaly() {
  const todayCost = await metrics.dailyCost('gemini');
  const sevenDayAvg = await metrics.avg('gemini.daily_cost', { days: 7 });
  if (todayCost > sevenDayAvg * 1.5 && todayCost > 5) {
    alert.send(`Gemini cost ${todayCost.toFixed(2)} > 150% of 7-day avg`);
  }
}

Registration → URL submit → extract → Modal Volume local + async B2
                                     ↓
                          Result UI: "10 компонентов готовы"
                          [Edit in ARNO] [Connect Git to push]
                                     ↓
                  Later: GitHub OAuth → push from staging

Phase 1 fail:
  → anti-bot signal? Hyperbrowser (1 retry)
  → network error? abort 'extraction_blocked'
  → timeout 30s? abort 'site_too_slow'

Phase 2 fail (capture matrix incomplete):
  → continue с partial matrix, flag missing combos

Phase 3 fail (coverage < 0.90):
  → Phase 4 LLM enrichment

Phase 4 fail (LLM timeout):
  → skip enrichment, Phase 5 с partial spec
  → mode 'code-only-degraded'

Phase 5 fail (generation error):
  → retry с alternative model (Cerebras → Gemini fallback)
  → still fails → abort 'generation_failed'

Phase 6 fail:
  → Phase 7

Phase 7 fail после full vision:
  → mode 'failed', save partial, manual review

Phase 8 fail (completeness < 0.5):
  → save с warning, flag manual review

Phase 9 fail (DINOv2/pgvector down):
  → skip uniqueness, default 'new'

Phase 10 fail (B2 down):
  → Modal Volume queue + async retry
  → > 1h queued → alert
  → 24h queued → notify юзер "delayed sync"

✅ Button (3 варианта, 2 темы) — code-only
✅ Card — code+vision (4 поля через vision)
⚠️ Modal — частично (vision-only, 78%) — hover на close не извлёкся
❌ CustomChart — не импортирован (canvas-rendered)

1. Email + password
2. Accept Terms of Service [← discloses shadow data usage]
3. "Расскажите о компании" (optional)
4. "У вас есть сайт? Импортируем компоненты"
   URL: [_______________________]
   ☑ Я владею правом на этот URL
   Лицензия: ⊙ Owned  ○ Licensed  ○ Public domain
   ⚠️ [warning для commercial sites из Tranco top 15k]
   [Импортировать] [Пропустить]

Импортируем example.com...

✅ Извлечён HTML/CSS                              2s
✅ Обнаружено 12 компонентов                       5s
🔄 Анализ тем (light + dark)        ║параллельно║ 8s
🔄 Захват состояний (5 states)      ║параллельно║ 12s
🔄 Захват viewports (4 размера)     ║параллельно║ 15s
🔄 Генерация компонентов (8/12)...                22s
🔄 Проверка соответствия (10/12)...               27s
✅ Готово                                          30s

Импортировано: 10 из 12 компонентов

✅ Button (3 варианта)         code-only       [Открыть]
✅ Card                         code+vision     [Открыть]
✅ Navbar                       code-only       [Открыть]
...
⚠️ Pricing (vision-only, 78%)                    [Re-extract] [Удалить]
❌ CustomChart (canvas)                          [Создать вручную]

[Открыть редактор]  [Импорт ещё URL]
[Connect Git to push to repo]  ← V1 only

Privacy Settings

  ☑ Anonymous data contribution
     Help improve ARNO by allowing anonymized usage data.
     [What we collect] [Delete past contributions]

  Account
     [Download my data] [Delete my account]

Trigger: calibrate когда earliest of:
  - 1000+ extractions accumulated, OR
  - 30 days since launch

→ analyze distribution → adjust thresholds на natural breakpoints
  target: 95% "fully extractable" cases passes coverage gate

Quarterly re-evaluate с минимум 1k new extractions.
Если volume не достиг 1k/quarter → keep current, document staleness.