uvako-cli 0.5.0 → 0.6.0

package/src/sections.js

@@ -0,0 +1,333 @@
+import { rules } from "./rules.generated.js";
+import { t } from "./i18n.js";
+
+// "engine": "sections" paketlerinin denetimi. Sunucudaki karşılıkları: theme/sections.go
+// (şema ve sayfa şablonu), theme/render (şablon sandbox'ı). Listeler ve sınırlar ortak
+// rules.json'dan gelir (src/rules.generated.js). Son karar her zaman sunucudadır; `uvako theme
+// check` giriş yapılmışsa sunucunun kuru denetimini de çalıştırır.
+
+const actionMark = "\x1a";
+const namePattern = /^[a-z0-9]+(?:[-_][a-z0-9]+)*$/;
+const sectionId = /^[a-z][a-z0-9_-]{0,63}$/;
+const settingId = /^[a-z][a-z0-9_]{0,63}$/;
+const colorPattern = /^#[0-9a-fA-F]{3}(?:[0-9a-fA-F]{3})?(?:[0-9a-fA-F]{2})?$/;
+const scriptPatterns = [/<script\b/i, /javascript:/i, /\son[a-z]+\s*=/i, /<iframe\b|<object\b|<embed\b|<foreignObject\b/i];
+const denied = { elements: new Set(rules.deniedElements), attributes: new Set(rules.deniedAttributes), urls: new Set(rules.urlAttributes), schemes: new Set(rules.urlSchemes) };
+const functions = new Set(rules.functions);
+const keywords = new Set(["if", "else", "end", "range", "with", "define", "template", "nil", "true", "false"]);
+
+/** Paket bölüm dosyası mı: templates/<sayfa>.json (index dışı), sections/, snippets/, layout/. */
+export function sectionFile(rel) {
+  const parts = rel.split("/");
+  if (parts.length !== 2 && rel !== "layout/theme.html.tmpl") return "";
+  if (rel === "layout/theme.html.tmpl") return "source";
+  if (parts[0] === "templates" && parts[1].endsWith(".json") && parts[1] !== "index.json" && rules.templates.includes(parts[1].slice(0, -5))) return "template";
+  if (parts[0] === "sections" && parts[1].endsWith(".schema.json")) return "schema";
+  if ((parts[0] === "sections" || parts[0] === "snippets") && parts[1].endsWith(".html.tmpl")) return "source";
+  return "";
+}
+
+// ── şablon: {{ … }} aksiyonları ve statik HTML ──────────────────────────────────────────────
+
+function actionEnd(s) {
+  const body = s.replace(/^-/, "").replace(/^[ \t\r\n]+/, "");
+  if (body.startsWith("/*")) {
+    const offset = s.length - body.length;
+    const close = body.indexOf("*/");
+    const end = close >= 0 ? body.slice(close).indexOf("}}") : -1;
+    if (end < 0) throw new Error(t("kapanmamış şablon aksiyonu"));
+    return { end: offset + close + end + 2, comment: true };
+  }
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === '"' || c === "'") {
+      for (i++; i < s.length && s[i] !== c; i++) {
+        if (s[i] === "\\") i++;
+        else if (s[i] === "\n") throw new Error(t("kapanmamış şablon aksiyonu"));
+      }
+      if (i >= s.length) throw new Error(t("kapanmamış şablon aksiyonu"));
+    } else if (c === "`") {
+      const close = s.indexOf("`", i + 1);
+      if (close < 0) throw new Error(t("kapanmamış şablon aksiyonu"));
+      i = close;
+    } else if (c === "}" && s[i + 1] === "}") {
+      return { end: i + 2, comment: false };
+    }
+  }
+  throw new Error(t("kapanmamış şablon aksiyonu"));
+}
+
+/** Aksiyonları işaretle değiştirir; aksiyon gövdelerini (yorumlar hariç) döndürür. */
+export function maskActions(source) {
+  let masked = "";
+  const actions = [];
+  let rest = source;
+  for (;;) {
+    const start = rest.indexOf("{{");
+    if (start < 0) return { masked: masked + rest, actions };
+    masked += rest.slice(0, start) + actionMark;
+    const { end, comment } = actionEnd(rest.slice(start + 2));
+    if (!comment) actions.push(rest.slice(start + 2, start + end).replace(/^-/, "").replace(/-?}}$/, "").trim());
+    rest = rest.slice(start + 2 + end);
+  }
+}
+
+const isLetter = (c) => /[A-Za-z]/.test(c ?? "");
+const isSpace = (c) => c === " " || c === "\t" || c === "\n" || c === "\r" || c === "\f";
+const strip = (value) => [...value].filter((c) => c > " " && c !== "\x7f").join("");
+const localName = (name) => (name !== "xlink:href" && name.includes(":") ? name.slice(name.lastIndexOf(":") + 1) : name);
+
+function decode(value) {
+  return value.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);?/gi, (whole, ref) => {
+    if (ref[0] === "#") {
+      const code = ref[1] === "x" || ref[1] === "X" ? parseInt(ref.slice(2), 16) : parseInt(ref.slice(1), 10);
+      return Number.isFinite(code) ? String.fromCodePoint(code) : whole;
+    }
+    return { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", colon: ":", tab: "\t", newline: "\n" }[ref.toLowerCase()] ?? whole;
+  });
+}
+
+function allowedURL(value) {
+  const compact = strip(value).toLowerCase();
+  const colon = compact.indexOf(":");
+  if (colon < 0 || /[/?#]/.test(compact.slice(0, colon))) return true;
+  return denied.schemes.has(compact.slice(0, colon));
+}
+
+function checkAttribute(name, value) {
+  const local = localName(name);
+  if (local.startsWith("on") || denied.attributes.has(local)) return t("izin verilmeyen öznitelik: {0}", name);
+  const text = decode(value).replaceAll(actionMark, "x");
+  if (denied.urls.has(name) || denied.urls.has(local)) {
+    if (!allowedURL(text)) return t("{0} içinde izin verilmeyen adres şeması", name);
+  } else if (local === "srcset") {
+    if (text.split(",").some((candidate) => candidate.trim() && !allowedURL(candidate.trim().split(/\s+/)[0]))) return t("srcset içinde izin verilmeyen adres şeması");
+  } else if (local === "style") {
+    const compact = strip(text).toLowerCase();
+    const bad = ["expression(", "javascript:", "vbscript:", "@import", "behavior:", "-moz-binding", "\\"].find((item) => compact.includes(item));
+    if (bad) return t("style özniteliğinde izin verilmeyen ifade: {0}", bad);
+  }
+  return "";
+}
+
+/** theme/render/html.go → checkHTML ile aynı kurallar (maskelenmiş şablon). */
+export function checkHTML(source) {
+  for (let i = 0; i < source.length;) {
+    const lt = source.indexOf("<", i);
+    if (lt < 0) return "";
+    i = lt + 1;
+    let rest = source.slice(i);
+    if (rest.startsWith("!--")) {
+      const end = rest.indexOf("-->", 3);
+      if (end < 0) return t("kapanmamış HTML yorumu");
+      i += end + 3;
+      continue;
+    }
+    if (rest.startsWith("!") || rest.startsWith("?")) {
+      if (!rest.toLowerCase().startsWith("!doctype html>")) return t("işaretleme bildirimi kullanılamaz");
+      continue;
+    }
+    const closing = rest.startsWith("/");
+    if (closing) {
+      i++;
+      rest = rest.slice(1);
+    }
+    if (!rest) return "";
+    if (rest.startsWith(actionMark)) return t("şablon aksiyonu etiket adı oluşturamaz");
+    if (!isLetter(rest[0])) continue;
+    let n = 0;
+    while (n < rest.length && !isSpace(rest[n]) && rest[n] !== ">" && rest[n] !== "/") n++;
+    const name = rest.slice(0, n).toLowerCase();
+    if (name.includes(actionMark)) return t("şablon aksiyonu etiket adı oluşturamaz");
+    if (denied.elements.has(name) || denied.elements.has(localName(name))) return t("izin verilmeyen etiket: {0}", name);
+    i += n;
+    if (closing) {
+      const end = source.indexOf(">", i);
+      if (end < 0) return t("kapanmamış etiket: {0}", name);
+      i = end + 1;
+      continue;
+    }
+    for (;;) {
+      while (i < source.length && (isSpace(source[i]) || source[i] === "/")) i++;
+      if (i >= source.length) return t("kapanmamış etiket: {0}", name);
+      if (source[i] === ">") {
+        i++;
+        break;
+      }
+      const start = i;
+      while (i < source.length && !isSpace(source[i]) && !"=>/".includes(source[i])) i++;
+      const attribute = source.slice(start, i).toLowerCase();
+      if (attribute.includes(actionMark)) return t("şablon aksiyonu öznitelik adı oluşturamaz");
+      while (i < source.length && isSpace(source[i])) i++;
+      let value = "";
+      if (source[i] === "=") {
+        i++;
+        while (i < source.length && isSpace(source[i])) i++;
+        if (source[i] === '"' || source[i] === "'") {
+          const end = source.indexOf(source[i], i + 1);
+          if (end < 0) return t("{0} etiketinde kapanmamış öznitelik değeri", name);
+          value = source.slice(i + 1, end);
+          i = end + 1;
+        } else {
+          const start = i;
+          while (i < source.length && !isSpace(source[i]) && source[i] !== ">") i++;
+          value = source.slice(start, i);
+        }
+      }
+      const problem = checkAttribute(attribute, value);
+      if (problem) return `${name}: ${problem}`;
+    }
+  }
+  return "";
+}
+
+/** Aksiyonlardaki fonksiyon, action, include ve define adlarını denetler. */
+function checkActions(actions, snippets, defines) {
+  const problems = [];
+  for (const action of actions) {
+    const bare = action.replace(/"(?:[^"\\]|\\.)*"|`[^`]*`|'(?:[^'\\]|\\.)*'/g, (literal) => (literal[0] === '"' ? `"${literal.slice(1, -1).replace(/\s/g, "_")}"` : '""'));
+    const words = [...bare.matchAll(/(^|[\s(|,])([A-Za-z_][A-Za-z0-9_]*)/g)].map((match) => match[2]);
+    const head = words[0];
+    if (head === "block" || head === "break" || head === "continue") problems.push(t("izin verilmeyen aksiyon: {0}", head));
+    for (const word of words) {
+      if (keywords.has(word) || functions.has(word) || word === "block" || word === "break" || word === "continue") continue;
+      problems.push(t("bilinmeyen fonksiyon: {0}", word));
+    }
+    const named = /^(template|define)\s+"([^"]*)"/.exec(action);
+    if (named) {
+      const [, kind, name] = named;
+      if (!name.startsWith("snippets/") || !namePattern.test(name.slice("snippets/".length))) problems.push(t("{0} yalnızca paketin snippets/ şablonlarını adlandırabilir: {1}", kind, name));
+      else if (kind === "template" && !snippets.has(name) && !defines.has(name)) problems.push(t("snippet bulunamadı: {0}", name));
+    }
+  }
+  return problems;
+}
+
+/** Bölüm/snippet/layout şablonları: yol, boyut, aksiyonlar ve statik HTML. */
+export function checkSources(sources, report) {
+  const snippets = new Set(Object.keys(sources).filter((rel) => rel.startsWith("snippets/")).map((rel) => rel.slice(0, -".html.tmpl".length)));
+  const defines = new Set();
+  for (const source of Object.values(sources)) for (const match of source.matchAll(/\{\{-?\s*define\s+"([^"]*)"/g)) defines.add(match[1]);
+  if (Object.keys(sources).length > 128) report.errors.push(t("Pakette en çok 128 bölüm şablonu olabilir."));
+  for (const [rel, source] of Object.entries(sources)) {
+    const handle = rel.split("/")[1]?.replace(/\.html\.tmpl$/, "") ?? "";
+    if (rel !== "layout/theme.html.tmpl" && !namePattern.test(handle)) report.errors.push(t("{0}: şablon adında yalnızca küçük harf, rakam, tire ve alt çizgi olabilir.", rel));
+    if (rel.startsWith("sections/") && handle in rules.platformSchemas) report.errors.push(t("{0}: platform bölümünün adı kullanılamaz; başka bir ad verin.", rel));
+    if (Buffer.byteLength(source) > rules.limits.templateBytes) {
+      report.errors.push(t("{0}: {1} KB sınırını aşıyor.", rel, rules.limits.templateBytes / 1024));
+      continue;
+    }
+    let masked;
+    try {
+      masked = maskActions(source);
+    } catch (error) {
+      report.errors.push(`${rel}: ${error.message}`);
+      continue;
+    }
+    const html = checkHTML(masked.masked);
+    if (html) report.errors.push(`${rel}: ${html}`);
+    for (const problem of checkActions(masked.actions, snippets, defines)) report.errors.push(`${rel}: ${problem}`);
+  }
+}
+
+/** {{ t "Metin" }} çağrılarındaki metinler: locales/ dosyalarında karşılığı aranır. */
+export function templateTexts(sources) {
+  const out = new Set();
+  for (const source of Object.values(sources)) {
+    for (const match of source.matchAll(/\{\{-?\s*t\s+"((?:[^"\\]|\\.)*)"/g)) {
+      try { out.add(JSON.parse(`"${match[1]}"`)); } catch { /* bozuk dize derlemede yakalanır */ }
+    }
+  }
+  return out;
+}
+
+// ── bölüm ayar şeması (theme/sections.go → validateSectionSchema) ──────────────────────────
+
+const safeText = (value) => {
+  if (typeof value === "string") return value.length <= 16384 && !scriptPatterns.some((pattern) => pattern.test(value));
+  return value === null || value === undefined || typeof value === "boolean" || typeof value === "number";
+};
+
+function validValue(setting, value) {
+  if (!safeText(value)) return false;
+  switch (setting.type) {
+    case "checkbox": return typeof value === "boolean";
+    case "number":
+    case "range": return typeof value === "number" && Number.isFinite(value) && (setting.min === undefined || value >= setting.min) && (setting.max === undefined || value <= setting.max);
+    default: {
+      if (typeof value !== "string") return false;
+      if (setting.type === "color") return value === "" || colorPattern.test(value);
+      if (setting.type === "url" || setting.type === "image") {
+        if (value === "") return true;
+        if (/[\0\r\n\t\\ ]/.test(value)) return false;
+        if (value.startsWith("/")) return !value.startsWith("//") && !value.includes("..");
+        try {
+          const url = new URL(value);
+          return url.protocol === "https:" && Boolean(url.host) && !url.username && !url.password;
+        } catch { return false; }
+      }
+      if (setting.type === "select") return (setting.options ?? []).some((option) => option.value === value);
+      return true;
+    }
+  }
+}
+
+const finite = (value) => value === undefined || (typeof value === "number" && Number.isFinite(value));
+
+export function checkSectionSchema(rel, schema, report) {
+  const fail = (text) => report.errors.push(t("{0}: bölüm ayar şeması geçersiz ({1}).", rel, text));
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return fail(t("nesne olmalı"));
+  if (typeof schema.name !== "string" || !schema.name.trim() || schema.name.length > 100) fail(t("\"name\" gerekli, en çok 100 karakter"));
+  const settings = schema.settings ?? [];
+  if (!Array.isArray(settings) || settings.length > rules.limits.sectionSettings) return fail(t("\"settings\" en çok {0} ayarlık bir liste olmalı", rules.limits.sectionSettings));
+  if (schema.fallback !== undefined && typeof schema.fallback !== "string") fail(t("\"fallback\" bir bölüm türü olmalı"));
+  const seen = new Set();
+  for (const setting of settings) {
+    const id = setting?.id;
+    if (!settingId.test(String(id ?? "")) || seen.has(id)) { fail(t("\"{0}\" ayar adı geçersiz ya da tekrarlı", String(id ?? ""))); continue; }
+    seen.add(id);
+    if (typeof setting.label !== "string" || !setting.label.trim() || setting.label.length > 150) fail(t("\"{0}\" ayarının \"label\" alanı gerekli", id));
+    if (!rules.settingTypes.includes(setting.type)) fail(t("\"{0}\" ayarının türü ({1}) bilinmiyor; kullanılabilir: {2}", id, String(setting.type), rules.settingTypes.join(", ")));
+    if (!finite(setting.min) || !finite(setting.max) || (setting.min !== undefined && setting.max !== undefined && setting.min > setting.max)) fail(t("\"{0}\" ayarının min/max değerleri geçersiz", id));
+    if (setting.step !== undefined && !(typeof setting.step === "number" && Number.isFinite(setting.step) && setting.step > 0)) fail(t("\"{0}\" ayarının step değeri geçersiz", id));
+    if (setting.type === "range" && (setting.min === undefined || setting.max === undefined)) fail(t("\"{0}\" (range) için min ve max gerekli", id));
+    if (setting.type === "select" && (!Array.isArray(setting.options) || setting.options.length === 0 || setting.options.length > 50)) fail(t("\"{0}\" (select) için 1-50 seçenek gerekli", id));
+    const values = new Set();
+    for (const option of Array.isArray(setting.options) ? setting.options : []) {
+      if (!option?.value || !option?.label || values.has(option.value)) fail(t("\"{0}\" ayarının seçenekleri geçersiz", id));
+      values.add(option?.value);
+    }
+    if (setting.default !== undefined && setting.default !== null && !validValue(setting, setting.default)) fail(t("\"{0}\" ayarının varsayılan değeri türüne uymuyor", id));
+  }
+}
+
+// ── sayfa şablonu (theme/sections.go → validatePageTemplate) ──────────────────────────────
+
+/** known.schemas: tür → şema (platform + paket), known.legacy: temel temanın bölüm türleri (bilinmiyorsa null). */
+export function checkPageTemplate(rel, tpl, known, report) {
+  const fail = (text) => report.errors.push(`${rel}: ${text}`);
+  if (!tpl || typeof tpl !== "object" || !tpl.sections || typeof tpl.sections !== "object" || !Array.isArray(tpl.order ?? [])) return fail(t("geçerli bir şablon değil ({\"order\": […], \"sections\": {…}})."));
+  const order = tpl.order ?? [];
+  if (order.length > 100 || Object.keys(tpl.sections).length > 100) fail(t("en çok 100 bölüm olabilir."));
+  const seen = new Set();
+  for (const id of order) {
+    if (!sectionId.test(String(id)) || seen.has(id)) fail(t("\"{0}\" bölüm kimliği geçersiz ya da tekrarlı.", String(id)));
+    else if (!(id in tpl.sections)) fail(t("\"order\" içindeki \"{0}\" bölümü \"sections\" altında yok.", id));
+    seen.add(id);
+  }
+  for (const [id, section] of Object.entries(tpl.sections)) {
+    if (!sectionId.test(id)) fail(t("\"{0}\" bölüm kimliği geçersiz.", id));
+    const type = String(section?.type ?? "");
+    const schema = known.schemas.get(type);
+    if (!schema && !type.startsWith("app:") && known.legacy && !known.legacy.has(type)) fail(t("\"{0}\" bölümünün türü ({1}) ne platformda ne pakette ne de temel temada var.", id, type));
+    if (!schema && !type.startsWith("app:") && !known.legacy && type.startsWith("pkg:")) fail(t("\"{0}\" bölümünün türü ({1}) pakette yok: sections/{2}.html.tmpl ekleyin.", id, type, type.slice(4)));
+    const defs = new Map((schema?.settings ?? []).map((setting) => [setting.id, setting]));
+    for (const [key, value] of Object.entries(section?.settings ?? {})) {
+      if (!safeText(value)) { fail(t("\"{0}\" bölümünün \"{1}\" ayarı betik ya da izin verilmeyen bir değer içeriyor.", id, key)); continue; }
+      if (schema && (!defs.has(key) || !validValue(defs.get(key), value))) fail(t("\"{0}\" bölümünün \"{1}\" ayarı şemada yok ya da türüne uymuyor.", id, key));
+    }
+  }
+}
+
+/** Platform bölümleri ve ayar şemaları: sunucuyla aynı rules.json'dan. */
+export const platformSchemas = new Map(Object.entries(rules.platformSchemas));

package/src/svg.js

@@ -0,0 +1,152 @@
+import sax from "sax";
+
+const svgNS = "http://www.w3.org/2000/svg";
+const xlinkNS = "http://www.w3.org/1999/xlink";
+const xmlNS = "http://www.w3.org/XML/1998/namespace";
+const maxBytes = 5 * 1024 * 1024;
+const names = (text) => new Set(text.split(/\s+/).filter(Boolean));
+
+// This static drawing profile mirrors backend/internal/theme/svg.go. Both implementations
+// run backend/internal/theme/testdata/svg.json to keep the upload and CLI decisions aligned.
+const elements = Object.fromEntries(Object.entries({
+  svg: "x y width height viewBox preserveAspectRatio version baseProfile",
+  g: "", defs: "", title: "", desc: "",
+  symbol: "viewBox preserveAspectRatio x y width height", use: "href x y width height",
+  image: "href x y width height preserveAspectRatio", path: "d pathLength",
+  rect: "x y width height rx ry pathLength", circle: "cx cy r pathLength", ellipse: "cx cy rx ry pathLength",
+  line: "x1 y1 x2 y2 pathLength", polyline: "points pathLength", polygon: "points pathLength",
+  text: "x y dx dy rotate textLength lengthAdjust", tspan: "x y dx dy rotate textLength lengthAdjust",
+  textPath: "href startOffset method spacing side textLength lengthAdjust",
+  linearGradient: "href x1 y1 x2 y2 gradientUnits gradientTransform spreadMethod",
+  radialGradient: "href cx cy r fx fy fr gradientUnits gradientTransform spreadMethod", stop: "offset",
+  clipPath: "clipPathUnits", mask: "x y width height maskUnits maskContentUnits mask-type",
+  pattern: "href x y width height patternUnits patternContentUnits patternTransform viewBox preserveAspectRatio",
+  marker: "viewBox preserveAspectRatio refX refY markerWidth markerHeight markerUnits orient",
+  filter: "x y width height filterUnits primitiveUnits", feBlend: "in in2 mode result x y width height",
+  feColorMatrix: "in type values result x y width height", feComponentTransfer: "in result x y width height",
+  feComposite: "in in2 operator k1 k2 k3 k4 result x y width height",
+  feConvolveMatrix: "in order kernelMatrix divisor bias targetX targetY edgeMode kernelUnitLength preserveAlpha result x y width height",
+  feDiffuseLighting: "in surfaceScale diffuseConstant kernelUnitLength result x y width height",
+  feDisplacementMap: "in in2 scale xChannelSelector yChannelSelector result x y width height",
+  feDistantLight: "azimuth elevation", feDropShadow: "in dx dy stdDeviation result x y width height",
+  feFlood: "result x y width height",
+  feFuncA: "type tableValues slope intercept amplitude exponent offset", feFuncB: "type tableValues slope intercept amplitude exponent offset",
+  feFuncG: "type tableValues slope intercept amplitude exponent offset", feFuncR: "type tableValues slope intercept amplitude exponent offset",
+  feGaussianBlur: "in stdDeviation edgeMode result x y width height", feImage: "href preserveAspectRatio result x y width height",
+  feMerge: "result x y width height", feMergeNode: "in", feMorphology: "in operator radius result x y width height",
+  feOffset: "in dx dy result x y width height", fePointLight: "x y z",
+  feSpecularLighting: "in surfaceScale specularConstant specularExponent kernelUnitLength result x y width height",
+  feSpotLight: "x y z pointsAtX pointsAtY pointsAtZ specularExponent limitingConeAngle",
+  feTile: "in result x y width height", feTurbulence: "baseFrequency numOctaves seed stitchTiles type result x y width height",
+}).map(([tag, attributes]) => [tag, names(attributes)]));
+
+const globalAttributes = names(`id class role aria-label aria-labelledby aria-describedby aria-hidden
+  fill fill-rule fill-opacity stroke stroke-width stroke-linecap stroke-linejoin stroke-miterlimit stroke-dasharray stroke-dashoffset stroke-opacity
+  opacity color stop-color stop-opacity flood-color flood-opacity lighting-color
+  clip-path clip-rule mask filter marker-start marker-mid marker-end
+  color-interpolation color-interpolation-filters color-rendering shape-rendering text-rendering image-rendering
+  display visibility overflow vector-effect paint-order pointer-events
+  font-family font-size font-style font-weight font-stretch text-anchor dominant-baseline alignment-baseline baseline-shift
+  letter-spacing word-spacing writing-mode direction unicode-bidi text-decoration transform`);
+
+const fragment = /^#[A-Za-z_][A-Za-z0-9_.:-]*$/;
+const localURL = /^url\([ \t\r\n]*(?:#[A-Za-z_][A-Za-z0-9_.:-]*|"#[A-Za-z_][A-Za-z0-9_.:-]*"|'#[A-Za-z_][A-Za-z0-9_.:-]*')[ \t\r\n]*\)$/i;
+const color = /^(?:#[0-9a-f]{3}|#[0-9a-f]{4}|#[0-9a-f]{6}|#[0-9a-f]{8}|[a-z]+|(?:rgb|rgba|hsl|hsla)\([0-9+.,% /\t\r\n-]+\))$/i;
+const declaration = /^version[ \t\r\n]*=[ \t\r\n]*(?:"1\.0"|'1\.0')(?:[ \t\r\n]+encoding[ \t\r\n]*=[ \t\r\n]*(?:"[Uu][Tt][Ff]-8"|'[Uu][Tt][Ff]-8'))?(?:[ \t\r\n]+standalone[ \t\r\n]*=[ \t\r\n]*(?:"(?:yes|no)"|'(?:yes|no)'))?[ \t\r\n]*$/;
+const whitespace = (text) => /^[ \t\r\n]*$/.test(text);
+const trim = (text) => text.replace(/^[ \t\r\n]+|[ \t\r\n]+$/g, "");
+const reject = (message) => { throw new Error(message); };
+
+function validXMLText(text) {
+  for (const char of text) {
+    const code = char.codePointAt(0);
+    if (!(code === 9 || code === 10 || code === 13 || (code >= 0x20 && code <= 0xD7FF) || (code >= 0xE000 && code <= 0xFFFD) || (code >= 0x10000 && code <= 0x10FFFF))) return false;
+  }
+  return true;
+}
+
+function validateValue(name, raw) {
+  if (!validXMLText(raw)) reject("SVG geçersiz XML karakteri içeriyor.");
+  const value = trim(raw);
+  if (/[\\<>`]/.test(value) || /javascript:|expression\(|-moz-binding|behavior:/i.test(value)) reject(`${name} özniteliği güvenli bir SVG değeri değil.`);
+  if (name === "href") {
+    if (!fragment.test(value)) reject("SVG href yalnızca yerel #kimlik bağlantısı olabilir.");
+  } else if (["fill", "stroke"].includes(name)) {
+    if (!color.test(value) && !localURL.test(value)) reject(`SVG ${name} yalnızca renk veya yerel url(#kimlik) olabilir.`);
+  } else if (["color", "stop-color", "flood-color", "lighting-color"].includes(name)) {
+    if (!color.test(value)) reject(`SVG ${name} geçerli bir renk olmalıdır.`);
+  } else if (["clip-path", "mask", "filter", "marker-start", "marker-mid", "marker-end"].includes(name)) {
+    if (value !== "none" && !localURL.test(value)) reject(`SVG ${name} yalnızca yerel url(#kimlik) olabilir.`);
+  } else if (/url[ \t\r\n]*\(/i.test(value)) reject(`SVG ${name} url() içeremez.`);
+}
+
+/** Returns an upload-compatible validation message, or an empty string for a static SVG. */
+export function checkSVG(input) {
+  try {
+    if (Buffer.byteLength(input) > maxBytes) reject("SVG dosya boyutu sınırını aşıyor.");
+    const source = (typeof input === "string" ? input : new TextDecoder("utf-8", { fatal: true }).decode(input)).replace(/^\uFEFF/, "");
+    if (!validXMLText(source)) reject("SVG geçersiz XML karakteri içeriyor.");
+    // Input is already bounded; large path attributes can exceed sax's default 64 KB buffer.
+    sax.MAX_BUFFER_LENGTH = maxBytes;
+    const parser = sax.parser(true, { xmlns: true, strictEntities: true });
+    let depth = 0;
+    let count = 0;
+    let root = false;
+    let declared = false;
+    let attributes = [];
+    let seen = new Set();
+    parser.onerror = (error) => { throw error; };
+    parser.ondoctype = parser.onsgmldeclaration = () => reject("SVG DOCTYPE veya varlık bildirimi içeremez.");
+    parser.onprocessinginstruction = (pi) => {
+      if (declared || !/^<\?xml[ \t\r\n]/.test(source) || pi.name !== "xml" || !declaration.test(pi.body)) reject("SVG işlem yönergesi içeremez.");
+      declared = true;
+    };
+    parser.onopentagstart = () => { attributes = []; seen = new Set(); };
+    parser.onattribute = (attr) => {
+      const key = `${attr.uri}\0${attr.local}`;
+      if (seen.has(key)) reject("SVG yinelenen öznitelik içeriyor.");
+      seen.add(key);
+      attributes.push(attr);
+      if (attributes.length > 64) reject("SVG yapı sınırını aşıyor.");
+    };
+    parser.onopentag = (node) => {
+      if (depth === 0) {
+        if (root || node.local !== "svg") reject("SVG tek bir svg kökü içermelidir.");
+        root = true;
+      }
+      if (++depth > 64 || ++count > 10000) reject("SVG yapı sınırını aşıyor.");
+      if (node.uri !== "" && node.uri !== svgNS) reject("SVG dışında ad alanı kullanılamaz.");
+      const allowed = elements[node.local];
+      if (!allowed || node.name.split(":").length > 2) reject(`<${node.local}> etiketi kullanılamaz.`);
+      for (const attr of attributes) {
+        if (attr.name.split(":").length > 2) reject("SVG öznitelik adı geçersiz.");
+        if (attr.prefix === "xmlns") {
+          const prefix = attr.name === "xmlns" ? "" : attr.local;
+          if (prefix === "xmlns" || (prefix === "xml" && attr.value !== xmlNS) ||
+              (attr.value !== svgNS && attr.value !== xlinkNS && !(prefix === "xml" && attr.value === xmlNS) && !(prefix === "" && attr.value === ""))) reject("SVG ad alanı bildirimi geçersiz.");
+          continue;
+        }
+        if (!attr.uri) {
+          if (!globalAttributes.has(attr.local) && !allowed.has(attr.local)) reject(`${attr.local} özniteliği kullanılamaz.`);
+        } else if (attr.uri === xlinkNS) {
+          if (attr.local !== "href" || !allowed.has("href")) reject("xlink özniteliği kullanılamaz.");
+        } else if (attr.uri === xmlNS) {
+          if (!["lang", "space"].includes(attr.local)) reject("xml özniteliği kullanılamaz.");
+        } else reject("SVG özniteliğinin ad alanı geçersiz.");
+        validateValue(attr.local, attr.value);
+      }
+    };
+    parser.onclosetag = () => { depth--; };
+    parser.ontext = (text) => {
+      if (!validXMLText(text) || (depth === 0 && !whitespace(text))) reject("SVG kökü dışında metin veya geçersiz XML karakteri kullanılamaz.");
+    };
+    parser.oncdata = (text) => {
+      if (depth === 0 || !validXMLText(text)) reject("SVG kökü dışında CDATA kullanılamaz.");
+    };
+    parser.write(source).close();
+    if (!root || depth !== 0) reject("geçerli bir SVG kökü yok.");
+    return "";
+  } catch (error) {
+    return error.message;
+  }
+}

package/templates/app/README.md

@@ -30,6 +30,32 @@ uvako app submit    # herkese açmak için Uvako incelemesine gönderir
 
 Client secret bu klasöre yazılmaz. Sunucunuzda `UVAKO_CLIENT_SECRET` ortam değişkeniyle verin.
 
+## Panelde açılma (gömülü uygulama)
+
+`"embedded": true` olduğu için uygulama mağaza panelinin içinde, bir iframe'de açılır:
+
+- Sayfa köprüyü mağazadan yükler: `<script src="https://<mağaza>/admin/app-bridge.js">`, sonra
+  `UvakoAppBridge.createApp()`. Bildirim, başlık, panel içi yönlendirme ve onay penceresi köprüdendir.
+- Sunucuya istekler `app.fetch(...)` ile gider: `Authorization: Bearer <oturum belirteci>`. Belirteç bir
+  dakikalık bir JWT'dir; `server.js` → `verifySessionToken` imzayı (client secret), `aud`, `exp` ve mağazayı
+  (`dest`) doğrular. Çerez kullanılmaz.
+- Sayfa `Content-Security-Policy: frame-ancestors https://<mağaza>` gönderir: başka sitelerde
+  çerçevelenemez.
+
+## Vitrin bloğu
+
+`blocks/yildiz-puani/` bir vitrin bloğu örneğidir: `block.json` (ad ve ayarlar), `block.html` (şablon),
+`block.css`. `uvako app deploy` blokları da gönderir. Mağaza bloğu tema editöründe **Uygulama bloğu ekle**
+ile ana sayfaya ekler. Şablonda kod çalışmaz: `{{ .settings.ad }}`, `if/else` ve `eq/ne/not/and/or`
+kullanılabilir.
+
+## Ücret alma
+
+**Pro plana geç** düğmesi `POST /api/billing` ile aylık bir ücret oluşturur ve mağazayı panelin onay
+sayfasına gönderir. Onaydan sonra panel `/billing/return?charge_id=…` adresine döner. Örnek varsayılan
+olarak test ücreti oluşturur (`UVAKO_TEST_CHARGES=0` ile gerçek ücret). Test ücreti yalnızca kendi
+geliştirme mağazalarınızda çalışır.
+
 ## Güvenlik
 
 - Kurulum dönüşünde `hmac` ve `state` doğrulanır; `shop` yalnızca `*.uvoo.store` olabilir.