npm - @birdapi/velinstyle - Versions diffs - 1.2.0 → 1.2.1 - Mend

@birdapi/velinstyle 1.2.0 → 1.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (39) hide show

package/README.de.md +22 -19
package/README.md +24 -25
package/cli/cli-manifest.json +1 -1
package/cli/docgen/extract-attributes.js +2 -0
package/cli/index.js +32 -3
package/cli/transparency.js +221 -0
package/core/a11y/component-contracts.json +1 -1
package/core/attributes/registry.js +14 -0
package/core/meta/schema.js +10 -0
package/core/transparency/attach.js +74 -0
package/core/transparency/claims.js +97 -0
package/core/transparency/doctor.js +142 -0
package/core/transparency/engine.js +75 -0
package/core/transparency/export.js +98 -0
package/core/transparency/index.js +30 -0
package/core/transparency/migrate.js +130 -0
package/core/transparency/normalize.js +125 -0
package/core/transparency/policy.js +105 -0
package/core/transparency/providers.js +235 -0
package/core/transparency/registry.js +104 -0
package/core/transparency/renderer.js +111 -0
package/core/transparency/reporter.js +113 -0
package/core/transparency/validator.js +112 -0
package/dist/chunks/attach-H2ZSEAE6.js +365 -0
package/dist/chunks/attributes-DZCXX2RZ.js +404 -0
package/dist/chunks/chunk-CQMTCEI6.js +113 -0
package/dist/chunks/runtime-entry.js +1 -1
package/dist/llms.txt +3 -2
package/dist/search-index.json +28 -2
package/dist/velin-agent.json +10 -6
package/dist/velinstyle-components.iife.js +411 -2
package/dist/velinstyle-components.js +411 -2
package/dist/velinstyle-components.min.js +113 -113
package/dist/velinstyle.css +160 -0
package/dist/velinstyle.min.css +1 -1
package/package.json +2 -1
package/packages/velinstyle-skills/catalog.json +1 -1
package/src/components/transparency.css +138 -0
package/src/velinstyle.css +1 -0

package/core/transparency/reporter.js ADDED Viewed

@@ -0,0 +1,113 @@
+/**
+ * Build report artifacts from a doctor result.
+ * @param {Awaited<ReturnType<import('./doctor.js').transparencyDoctor>>} report
+ * @param {{ title?: string }} [opts]
+ */
+export function buildTransparencyReports(report, opts = {}) {
+  const title = opts.title || 'Velin Transparency Report';
+  const json = {
+    schema: 'velinstyle.transparency.report',
+    version: 1,
+    generatedAt: new Date().toISOString(),
+    title,
+    ...report,
+  };
+  const sarif = toSarif(report, title);
+  const html = toHtml(report, title);
+  return { json, sarif, html };
+}
+function toSarif(report, title) {
+  const results = (report.findings || []).map((f) => ({
+    ruleId: f.code,
+    level: f.severity === 'error' ? 'error' : f.severity === 'warning' ? 'warning' : 'note',
+    message: { text: f.message },
+    locations: f.id || f.target
+      ? [{
+        physicalLocation: {
+          artifactLocation: { uri: report.file || 'document.html' },
+          region: { snippet: { text: f.id || f.target?.src || '' } },
+        },
+      }]
+      : [],
+  }));
+  return {
+    $schema: 'https://json.schemastore.org/sarif-2.1.0.json',
+    version: '2.1.0',
+    runs: [{
+      tool: {
+        driver: {
+          name: 'velinstyle-transparency',
+          informationUri: 'https://velinstyle.info',
+          rules: [],
+        },
+      },
+      results,
+      properties: { title, scores: report.scores },
+    }],
+  };
+}
+function toHtml(report, title) {
+  const scores = report.scores || {};
+  const rows = (report.findings || []).map((f) => `
+    <tr>
+      <td>${esc(f.severity)}</td>
+      <td><code>${esc(f.code)}</code></td>
+      <td>${esc(f.message)}</td>
+      <td>${esc(f.id || '')}</td>
+    </tr>`).join('');
+  const items = (report.registry?.items || []).map((r) => `
+    <tr>
+      <td><code>${esc(r.id)}</code></td>
+      <td>${esc(r.type)}</td>
+      <td>${esc(r.label)}</td>
+      <td>${esc((r.claims || []).join(', '))}</td>
+      <td>${esc(JSON.stringify(r.provenance || {}))}</td>
+    </tr>`).join('');
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>${esc(title)}</title>
+  <style>
+    body{font-family:system-ui,sans-serif;margin:2rem;background:#0c0b0a;color:#f5f2eb}
+    table{border-collapse:collapse;width:100%;margin-block:1rem}
+    th,td{border:1px solid #333;padding:.5rem;text-align:left;vertical-align:top}
+    th{background:#1a1917}
+    .scores{display:flex;flex-wrap:wrap;gap:.75rem}
+    .score{padding:.75rem 1rem;background:#1a1917;border-radius:8px;min-width:7rem}
+    .ok{color:#7ddea0}.bad{color:#f5a5a5}
+  </style>
+</head>
+<body>
+  <h1>${esc(title)}</h1>
+  <p class="${report.ok ? 'ok' : 'bad'}">${report.ok ? 'PASS' : 'FAIL'} — ${report.summary?.errors || 0} errors, ${report.summary?.warnings || 0} warnings</p>
+  <div class="scores">
+    ${scoreCard('Transparency', scores.transparency)}
+    ${scoreCard('AI', scores.ai)}
+    ${scoreCard('Trust', scores.trust)}
+    ${scoreCard('Metadata', scores.metadata)}
+    ${scoreCard('Compliance', scores.compliance)}
+    ${scoreCard('Provenance', scores.provenance)}
+  </div>
+  <h2>Findings</h2>
+  <table><thead><tr><th>Severity</th><th>Code</th><th>Message</th><th>Id</th></tr></thead><tbody>${rows || '<tr><td colspan="4">None</td></tr>'}</tbody></table>
+  <h2>Registry</h2>
+  <table><thead><tr><th>Id</th><th>Type</th><th>Label</th><th>Claims</th><th>Provenance</th></tr></thead><tbody>${items || '<tr><td colspan="5">Empty</td></tr>'}</tbody></table>
+</body>
+</html>`;
+}
+function scoreCard(name, value) {
+  const v = value == null ? '—' : `${value}%`;
+  return `<div class="score"><strong>${esc(name)}</strong><div>${v}</div></div>`;
+}
+function esc(s) {
+  return String(s ?? '')
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}

package/core/transparency/validator.js ADDED Viewed

@@ -0,0 +1,112 @@
+import { CLAIM_CATALOG } from './claims.js';
+import { requiredProvenanceFields } from './policy.js';
+const VALID_STATUS = new Set([
+  'generated', 'assisted', 'ai-assisted', 'human-reviewed', 'human-edited', 'verified', 'edited', 'draft',
+]);
+const VALID_REVIEW = new Set(['human', 'human-reviewed', 'verified', 'none']);
+const VALID_TYPES = new Set([
+  'ai', 'trust', 'compliance', 'metadata', 'review', 'verification', 'license',
+  'accessibility', 'security', 'custom', 'image', 'video', 'audio', 'text', 'pdf', 'document',
+]);
+/**
+ * @param {import('./registry.js').DisclosureRecord} record
+ * @param {object} policy
+ */
+export function validateRecord(record, policy) {
+  const findings = [];
+  if (!record?.id) {
+    findings.push(finding('error', 'invalid.id', 'Disclosure missing id'));
+  }
+  if (record.type && !VALID_TYPES.has(String(record.type).toLowerCase())) {
+    findings.push(finding('warning', 'invalid.type', `Unknown type "${record.type}"`, record.id));
+  }
+  if (record.status && !VALID_STATUS.has(String(record.status).toLowerCase())) {
+    findings.push(finding('error', 'invalid.status', `Invalid status "${record.status}"`, record.id));
+  }
+  if (record.review && !VALID_REVIEW.has(String(record.review).toLowerCase())) {
+    findings.push(finding('error', 'invalid.review', `Invalid review "${record.review}"`, record.id));
+  }
+  if (!record.label) {
+    findings.push(finding('warning', 'missing.label', 'Missing label', record.id));
+  }
+  if (policy.rules?.requireReview && !record.review && !record.claims?.includes('review.human')) {
+    findings.push(finding('error', 'policy.requireReview', 'Policy requires review', record.id));
+  }
+  if (policy.rules?.allowGenerated === false && record.claims?.includes('ai.generated')) {
+    findings.push(finding('error', 'policy.allowGenerated', 'Generated content not allowed by policy', record.id));
+  }
+  if (policy.rules?.minimumStatus === 'human-reviewed') {
+    const ok = record.claims?.includes('review.human') || record.claims?.includes('review.verified')
+      || record.review === 'human' || record.review === 'human-reviewed' || record.review === 'verified';
+    if (!ok && (record.claims?.includes('ai.generated') || record.claims?.includes('ai.assisted'))) {
+      findings.push(finding('error', 'policy.minimumStatus', 'minimumStatus human-reviewed not met', record.id));
+    }
+  }
+  for (const claim of record.claims || []) {
+    if (!CLAIM_CATALOG[claim] && !String(claim).startsWith('custom.')) {
+      findings.push(finding('warning', 'unknown.claim', `Unknown claim "${claim}"`, record.id));
+    }
+  }
+  const mediaKind = inferMediaKind(record);
+  const required = requiredProvenanceFields(mediaKind, policy);
+  for (const field of required) {
+    if (!record.provenance?.[field]) {
+      findings.push(finding('error', `missing-provenance.${field}`, `Missing provenance.${field}`, record.id));
+    }
+  }
+  for (const field of policy.provenance?.recommended || []) {
+    if (!record.provenance?.[field]) {
+      findings.push(finding('info', `recommended-provenance.${field}`, `Recommended provenance.${field}`, record.id));
+    }
+  }
+  if (record.updated || record.provenance?.reviewedAt) {
+    const staleDays = policy.rules?.staleDays ?? 365;
+    const dateStr = record.provenance?.reviewedAt || record.updated;
+    const age = ageDays(dateStr);
+    if (age != null && age > staleDays) {
+      findings.push(finding('warning', 'stale-reviewedAt', `Review/update is ${age} days old (limit ${staleDays})`, record.id));
+    }
+  }
+  return findings;
+}
+/**
+ * @param {import('./registry.js').DisclosureRecord[]} records
+ * @param {object} policy
+ */
+export function validateRecords(records, policy) {
+  const findings = [];
+  const seen = new Map();
+  for (const r of records) {
+    if (seen.has(r.id)) {
+      findings.push(finding('error', 'duplicate.id', `Duplicate disclosure id "${r.id}"`, r.id));
+    }
+    seen.set(r.id, true);
+    findings.push(...validateRecord(r, policy));
+  }
+  return findings;
+}
+export function inferMediaKind(record) {
+  const tag = String(record.target?.tag || '').toUpperCase();
+  const type = String(record.type || '').toLowerCase();
+  const src = String(record.target?.src || '');
+  if (tag === 'IMG' || type === 'image' || /\.(png|jpe?g|webp|gif|svg)(\?|$)/i.test(src)) return 'images';
+  if (tag === 'VIDEO' || type === 'video' || /\.(mp4|webm|mov)(\?|$)/i.test(src)) return 'videos';
+  if (tag === 'AUDIO' || type === 'audio' || /\.(mp3|wav|ogg)(\?|$)/i.test(src)) return 'audio';
+  if (type === 'pdf' || /\.pdf(\?|$)/i.test(src)) return 'pdf';
+  return 'text';
+}
+function ageDays(dateStr) {
+  if (!dateStr) return null;
+  const t = Date.parse(dateStr);
+  if (Number.isNaN(t)) return null;
+  return Math.floor((Date.now() - t) / 86400000);
+}
+function finding(severity, code, message, id) {
+  return { severity, code, message, id: id || null };
+}

package/dist/chunks/attach-H2ZSEAE6.js ADDED Viewed

@@ -0,0 +1,365 @@
+// core/transparency/claims.js
+var CLAIM_CATALOG = {
+  "ai.generated": { pillar: "ai", label: { en: "AI generated", de: "KI-generiert" } },
+  "ai.assisted": { pillar: "ai", label: { en: "AI assisted", de: "KI-unterst\xFCtzt" } },
+  "review.human": { pillar: "ai", label: { en: "Human reviewed", de: "Mensch gepr\xFCft" } },
+  "review.verified": { pillar: "trust", label: { en: "Verified", de: "Verifiziert" } },
+  "security.checked": { pillar: "trust", label: { en: "Security checked", de: "Security gepr\xFCft" } },
+  "accessibility.checked": { pillar: "trust", label: { en: "Accessibility checked", de: "Barrierefreiheit gepr\xFCft" } },
+  "trust.official": { pillar: "trust", label: { en: "Official", de: "Offiziell" } },
+  "trust.signed": { pillar: "trust", label: { en: "Signed", de: "Signiert" } },
+  "trust.opensource": { pillar: "trust", label: { en: "Open source", de: "Open Source" } },
+  "privacy.gdpr": { pillar: "compliance", label: { en: "GDPR", de: "DSGVO" } },
+  "license.cc-by": { pillar: "compliance", label: { en: "CC BY", de: "CC BY" } },
+  "license.mit": { pillar: "compliance", label: { en: "MIT", de: "MIT" } },
+  "license.apache-2": { pillar: "compliance", label: { en: "Apache-2.0", de: "Apache-2.0" } },
+  "content.updated": { pillar: "metadata", label: { en: "Updated", de: "Aktualisiert" } },
+  "content.author": { pillar: "metadata", label: { en: "Author", de: "Autor" } },
+  "content.source": { pillar: "metadata", label: { en: "Source", de: "Quelle" } },
+  "content.language": { pillar: "metadata", label: { en: "Language", de: "Sprache" } },
+  "version.current": { pillar: "metadata", label: { en: "Version", de: "Version" } },
+  "provenance.complete": { pillar: "provenance", label: { en: "Provenance complete", de: "Nachweis vollst\xE4ndig" } }
+};
+var STATUS_TO_CLAIM = {
+  generated: "ai.generated",
+  assisted: "ai.assisted",
+  "ai-assisted": "ai.assisted",
+  "human-reviewed": "review.human",
+  "human-edited": "review.human",
+  verified: "review.verified",
+  edited: "review.human",
+  draft: null
+};
+var REVIEW_TO_CLAIM = {
+  human: "review.human",
+  "human-reviewed": "review.human",
+  verified: "review.verified",
+  none: null
+};
+var LICENSE_TO_CLAIM = {
+  "cc by 4.0": "license.cc-by",
+  "cc-by": "license.cc-by",
+  "cc-by-4.0": "license.cc-by",
+  mit: "license.mit",
+  "apache-2.0": "license.apache-2",
+  apache: "license.apache-2"
+};
+function deriveClaims({ status, review, license, claims = [] } = {}) {
+  const out = new Set(Array.isArray(claims) ? claims.filter(Boolean) : []);
+  const statusClaim = STATUS_TO_CLAIM[String(status || "").toLowerCase()];
+  if (statusClaim) out.add(statusClaim);
+  const reviewClaim = REVIEW_TO_CLAIM[String(review || "").toLowerCase()];
+  if (reviewClaim) out.add(reviewClaim);
+  if (license) {
+    const key = String(license).toLowerCase().trim();
+    const mapped = LICENSE_TO_CLAIM[key] || (key.startsWith("cc") ? "license.cc-by" : null);
+    if (mapped) out.add(mapped);
+  }
+  return [...out];
+}
+function claimLabel(claim, lang = "en") {
+  const entry = CLAIM_CATALOG[claim];
+  if (!entry) return claim;
+  return entry.label[lang] || entry.label.en || claim;
+}
+function primaryLabel(claims = [], lang = "en") {
+  const order = ["ai.generated", "ai.assisted", "review.human", "review.verified", "trust.official", "license.cc-by", "license.mit"];
+  for (const c of order) {
+    if (claims.includes(c)) return claimLabel(c, lang);
+  }
+  if (claims[0]) return claimLabel(claims[0], lang);
+  return lang === "de" ? "Transparenz" : "Transparency";
+}
+// core/transparency/registry.js
+function createRegistry() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    register(record) {
+      if (!record?.id) throw new Error("DisclosureRecord requires id");
+      map.set(record.id, structuredCloneSafe(record));
+      return map.get(record.id);
+    },
+    get(id) {
+      return map.get(id) || null;
+    },
+    has(id) {
+      return map.has(id);
+    },
+    remove(id) {
+      return map.delete(id);
+    },
+    list() {
+      return [...map.values()].map((r) => structuredCloneSafe(r));
+    },
+    query(predicate) {
+      return this.list().filter(predicate);
+    },
+    clear() {
+      map.clear();
+    },
+    size() {
+      return map.size;
+    },
+    export() {
+      return { schema: "velinstyle.transparency.registry", version: 1, items: this.list() };
+    },
+    diff(otherList = []) {
+      const other = new Map(otherList.map((r) => [r.id, r]));
+      const added = [];
+      const removed = [];
+      const changed = [];
+      for (const r of map.values()) {
+        if (!other.has(r.id)) added.push(r.id);
+        else if (JSON.stringify(r) !== JSON.stringify(other.get(r.id))) changed.push(r.id);
+      }
+      for (const id of other.keys()) {
+        if (!map.has(id)) removed.push(id);
+      }
+      return { added, removed, changed };
+    }
+  };
+}
+function structuredCloneSafe(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+function stableDisclosureId(parts = {}) {
+  if (parts.id) return String(parts.id).trim();
+  const raw = [parts.file || "", parts.selector || "", parts.src || "", parts.tag || "", parts.type || ""].join("|").toLowerCase();
+  let h = 2166136261;
+  for (let i = 0; i < raw.length; i += 1) {
+    h ^= raw.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return `tx-${(h >>> 0).toString(16)}`;
+}
+// core/transparency/normalize.js
+var PROVENANCE_KEYS = [
+  "createdBy",
+  "createdAt",
+  "reviewedAt",
+  "approvedBy",
+  "source",
+  "license",
+  "version",
+  "publishedAt"
+];
+function normalizeDisclosure(draft = {}, ctx = {}) {
+  const provider = String(draft.provider || ctx.provider || "api");
+  const type = String(draft.type || "ai").toLowerCase();
+  const status = draft.status != null ? String(draft.status).toLowerCase() : void 0;
+  const review = draft.review != null ? String(draft.review).toLowerCase() : void 0;
+  const provenance = normalizeProvenance(draft.provenance || draft);
+  if (draft.license && !provenance.license) provenance.license = String(draft.license);
+  if (draft.model && !provenance.source) provenance.source = `model:${draft.model}`;
+  if (draft.generated === true && !status) {
+  }
+  const resolvedStatus = status || (draft.generated === true ? "generated" : void 0);
+  const claims = deriveClaims({
+    status: resolvedStatus,
+    review,
+    license: provenance.license,
+    claims: draft.claims
+  });
+  const target = {
+    selector: draft.target?.selector || draft.selector || void 0,
+    tag: draft.target?.tag || draft.tag || void 0,
+    src: draft.target?.src || draft.src || void 0,
+    file: draft.target?.file || ctx.file || draft.file || void 0
+  };
+  const id = stableDisclosureId({
+    id: draft.id || draft.velinTransparencyId,
+    selector: target.selector,
+    src: target.src,
+    tag: target.tag,
+    type,
+    file: target.file
+  });
+  const lang = ctx.lang === "de" ? "de" : "en";
+  const label = draft.label ? String(draft.label) : primaryLabel(claims, lang);
+  const updated = draft.updated || provenance.publishedAt || provenance.reviewedAt || provenance.createdAt || void 0;
+  return {
+    id,
+    type,
+    status: resolvedStatus,
+    review,
+    provider,
+    claims,
+    provenance,
+    updated,
+    label,
+    description: draft.description ? String(draft.description) : void 0,
+    renderer: draft.renderer || draft.overlay || "badge",
+    tone: draft.tone || toneFromClaims(claims),
+    position: draft.position || "top-right",
+    target,
+    meta: draft.meta && typeof draft.meta === "object" ? draft.meta : void 0
+  };
+}
+function normalizeProvenance(src = {}) {
+  const out = {};
+  for (const key of PROVENANCE_KEYS) {
+    const v = src[key] ?? src[key.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`)];
+    if (v != null && String(v).trim()) out[key] = String(v).trim();
+  }
+  if (src["created-by"]) out.createdBy = String(src["created-by"]);
+  if (src["created-at"]) out.createdAt = String(src["created-at"]);
+  if (src["reviewed-at"]) out.reviewedAt = String(src["reviewed-at"]);
+  if (src["approved-by"]) out.approvedBy = String(src["approved-by"]);
+  if (src["published-at"]) out.publishedAt = String(src["published-at"]);
+  return out;
+}
+function toneFromClaims(claims) {
+  if (claims.includes("ai.generated")) return "generated";
+  if (claims.includes("review.verified") || claims.includes("trust.official")) return "verified";
+  if (claims.includes("review.human")) return "human";
+  if (claims.includes("ai.assisted")) return "mixed";
+  return "neutral";
+}
+// core/transparency/renderer.js
+var renderers = /* @__PURE__ */ new Map();
+function registerTransparencyRenderer(name, fn) {
+  renderers.set(name, fn);
+}
+function renderDisclosure(el, record) {
+  if (typeof document === "undefined" || !el) return null;
+  const name = record.renderer || "badge";
+  const custom = renderers.get(name);
+  if (custom) {
+    custom(el, record);
+    return el.querySelector(".velin-transparency");
+  }
+  return defaultRender(el, record);
+}
+function defaultRender(el, record) {
+  const cs = getComputedStyle(el);
+  if (cs.position === "static") el.style.position = "relative";
+  let mark = el.querySelector(":scope > .velin-transparency");
+  if (!mark) {
+    mark = document.createElement("div");
+    el.prepend(mark);
+  }
+  const renderer = record.renderer || "badge";
+  const tone = record.tone || "neutral";
+  const position = record.position || "top-right";
+  mark.className = [
+    "velin-transparency",
+    `velin-transparency--${renderer}`,
+    `velin-transparency--tone-${tone}`,
+    `velin-transparency--pos-${position}`
+  ].join(" ");
+  mark.setAttribute("data-velin-transparency-id", record.id);
+  mark.setAttribute("role", "note");
+  const claimsText = (record.claims || []).join(", ");
+  const prov = record.provenance || {};
+  const sr = document.createElement("span");
+  sr.className = "velin-sr-only";
+  const lang = (el.closest("[lang]")?.getAttribute("lang") || document.documentElement.lang || "en").startsWith("de") ? "de" : "en";
+  sr.textContent = lang === "de" ? `Transparenzhinweis: ${record.label}. ${claimsText}. ${provenanceSr(prov, "de")}` : `Transparency notice: ${record.label}. ${claimsText}. ${provenanceSr(prov, "en")}`;
+  const visible = document.createElement("span");
+  visible.className = "velin-transparency__label";
+  visible.textContent = record.label || "Transparency";
+  const details = document.createElement("span");
+  details.className = "velin-transparency__details";
+  details.hidden = renderer === "badge" || renderer === "icon";
+  details.textContent = formatDetails(record, lang);
+  mark.replaceChildren(sr, visible, details);
+  if (record.description) mark.title = record.description;
+  else if (details.textContent) mark.title = details.textContent;
+  el.setAttribute("data-velin-transparency", record.id);
+  return mark;
+}
+function provenanceSr(p, lang) {
+  const parts = [];
+  if (p.createdBy) parts.push(lang === "de" ? `Erstellt von ${p.createdBy}` : `Created by ${p.createdBy}`);
+  if (p.createdAt) parts.push(lang === "de" ? `am ${p.createdAt}` : `on ${p.createdAt}`);
+  if (p.approvedBy) parts.push(lang === "de" ? `Freigegeben von ${p.approvedBy}` : `Approved by ${p.approvedBy}`);
+  if (p.license) parts.push(p.license);
+  if (p.version) parts.push(`v${p.version}`);
+  return parts.join(". ");
+}
+function formatDetails(record, lang) {
+  const p = record.provenance || {};
+  const bits = [];
+  if (p.approvedBy) bits.push(lang === "de" ? `Freigabe: ${p.approvedBy}` : `Approved: ${p.approvedBy}`);
+  if (p.license) bits.push(p.license);
+  if (p.version) bits.push(`v${p.version}`);
+  if (p.updated || record.updated) bits.push(record.updated || p.publishedAt || "");
+  return bits.filter(Boolean).join(" \xB7 ");
+}
+for (const name of ["overlay", "badge", "inline", "tooltip", "footer", "ribbon", "panel", "icon", "corner-badge", "stamp", "sidebar", "floating-card", "banner"]) {
+  registerTransparencyRenderer(name, (el, record) => {
+    defaultRender(el, { ...record, renderer: normalizeRendererName(name) });
+  });
+}
+function normalizeRendererName(name) {
+  if (name === "corner-badge" || name === "stamp") return "badge";
+  if (name === "floating-card" || name === "sidebar") return "panel";
+  if (name === "banner") return "footer";
+  return name;
+}
+// core/transparency/attach.js
+var defaultRegistry = createRegistry();
+function attach(el, options = {}, ctx = {}) {
+  if (!el) throw new Error("VelinTransparency.attach requires an element");
+  const registry = ctx.registry || defaultRegistry;
+  const draft = {
+    ...options,
+    tag: el.tagName,
+    src: el.getAttribute?.("src") || el.getAttribute?.("href") || options.src,
+    selector: el.id ? `#${el.id}` : options.selector,
+    id: options.id || el.getAttribute?.("velin-transparency-id") || el.id,
+    provider: options.provider || "api"
+  };
+  if (el.hasAttribute?.("velin-transparency") || el.hasAttribute?.("velin-disclosure")) {
+    draft.type = draft.type || el.getAttribute("velin-type") || "ai";
+    draft.status = draft.status || el.getAttribute("velin-status");
+    draft.review = draft.review || el.getAttribute("velin-review");
+    draft.license = draft.license || el.getAttribute("velin-license");
+    draft.label = draft.label || el.getAttribute("velin-label");
+    draft.description = draft.description || el.getAttribute("velin-description");
+    draft.overlay = draft.overlay || el.getAttribute("velin-overlay") || el.getAttribute("velin-renderer");
+    draft.provenance = {
+      createdBy: el.getAttribute("velin-created-by"),
+      createdAt: el.getAttribute("velin-created-at"),
+      reviewedAt: el.getAttribute("velin-reviewed-at"),
+      approvedBy: el.getAttribute("velin-approved-by"),
+      source: el.getAttribute("velin-source"),
+      license: el.getAttribute("velin-license"),
+      version: el.getAttribute("velin-version"),
+      publishedAt: el.getAttribute("velin-published-at"),
+      ...options.provenance || {}
+    };
+  }
+  const record = normalizeDisclosure(draft, { provider: draft.provider, lang: ctx.lang });
+  registry.register(record);
+  if (!el.hasAttribute("velin-transparency")) el.setAttribute("velin-transparency", "");
+  if (!el.hasAttribute("velin-transparency-id")) el.setAttribute("velin-transparency-id", record.id);
+  renderDisclosure(el, record);
+  return record;
+}
+function enhanceAll(root = typeof document !== "undefined" ? document : null) {
+  if (!root?.querySelectorAll) return [];
+  const out = [];
+  root.querySelectorAll("[velin-transparency], [velin-disclosure]").forEach((el) => {
+    out.push(attach(el, {}, { registry: defaultRegistry }));
+  });
+  return out;
+}
+function getDefaultRegistry() {
+  return defaultRegistry;
+}
+var VelinTransparency = {
+  attach,
+  enhanceAll,
+  getRegistry: getDefaultRegistry
+};
+export {
+  VelinTransparency,
+  attach,
+  enhanceAll,
+  getDefaultRegistry
+};