@pixerate/editor 0.164.0 → 0.165.0

package/dist/{chunk-NHLYK3AX.js → chunk-XBQX76CT.js}

@@ -3,6 +3,42 @@ import {
   stripPrototypeKeys
 } from "./chunk-HF5QZS7Z.js";
 
+// src/persistence/assetWrites.ts
+var leases = /* @__PURE__ */ new Map();
+var watchers = /* @__PURE__ */ new Set();
+function leaseAssetRefs(refs) {
+  const held = [...new Set(refs)];
+  for (const ref of held) {
+    leases.set(ref, (leases.get(ref) ?? 0) + 1);
+    for (const touched of watchers) touched.add(ref);
+  }
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    for (const ref of held) {
+      const n = (leases.get(ref) ?? 1) - 1;
+      if (n > 0) leases.set(ref, n);
+      else leases.delete(ref);
+    }
+  };
+}
+function watchAssetLeases() {
+  const touched = new Set(leases.keys());
+  watchers.add(touched);
+  return { touched, stop: () => void watchers.delete(touched) };
+}
+function withAssetLock(prefix, mode, task) {
+  let locks;
+  try {
+    locks = globalThis.navigator?.locks;
+  } catch {
+    locks = void 0;
+  }
+  if (!locks || typeof locks.request !== "function") return task();
+  return locks.request(`pixerate-editor-assets:${prefix}`, { mode }, task);
+}
+
 // src/persistence/assets.ts
 var EDITOR_ASSET_PREFIX = "pixerate-asset:";
 var REF = /pixerate-asset:[0-9a-z]+-[0-9a-z]+(?:~[0-9]+)?/g;
@@ -45,7 +81,8 @@ function createEditorAssetRegistry() {
     },
     get size() {
       return byRef.size;
-    }
+    },
+    refs: () => [...byRef.keys()]
   };
 }
 function externalizeAssets(value, registry) {
@@ -85,11 +122,22 @@ function internalizeAssets(value, registry) {
   return walk(value);
 }
 var persisted = /* @__PURE__ */ new WeakMap();
-var assetKey = (ref, options) => `${options.prefix ?? "pixerate.assets:"}${ref.slice(EDITOR_ASSET_PREFIX.length)}`;
+var assetPrefix = (options) => options.prefix ?? "pixerate.assets:";
+var assetKey = (ref, options) => `${assetPrefix(options)}${ref.slice(EDITOR_ASSET_PREFIX.length)}`;
+var markerKey = (options) => `${assetPrefix(options)}#collected`;
+var ASSET_ID = /^[0-9a-z]+-[0-9a-z]+(?:~[0-9]+)?$/;
 async function persistEditorAssets(storage, registry, document, options = {}) {
-  const written = persisted.get(storage) ?? /* @__PURE__ */ new Set();
-  persisted.set(storage, written);
-  for (const ref of collectAssetRefs(document)) {
+  const refs = collectAssetRefs(document);
+  if (!refs.length) return;
+  const cache = persisted.get(storage) ?? { marker: void 0, keys: /* @__PURE__ */ new Set() };
+  persisted.set(storage, cache);
+  const marker = await storage.get(markerKey(options)).catch(() => void 0);
+  if (marker === void 0 || marker !== cache.marker) {
+    cache.keys.clear();
+    cache.marker = marker;
+  }
+  const written = cache.keys;
+  for (const ref of refs) {
     const key = assetKey(ref, options);
     if (written.has(key)) continue;
     const data = registry.get(ref);
@@ -120,12 +168,135 @@ function withEditorAssets(storage, registry, options = {}) {
       return value;
     },
     async set(key, value) {
-      if (value.includes(EDITOR_ASSET_PREFIX)) await persistEditorAssets(storage, registry, value, options);
-      await storage.set(key, value);
+      if (!value.includes(EDITOR_ASSET_PREFIX)) return storage.set(key, value);
+      await writeWithAssets(storage, registry, value, options, () => storage.set(key, value));
     },
-    remove: (key) => storage.remove(key)
+    remove: (key) => storage.remove(key),
+    ...storage.keys ? { keys: (prefix) => storage.keys(prefix) } : {}
   };
 }
+async function writeWithAssets(storage, registry, document, options, write) {
+  const release = leaseAssetRefs(collectAssetRefs(document));
+  try {
+    await withAssetLock(assetPrefix(options), "shared", async () => {
+      if (registry) await persistEditorAssets(storage, registry, document, options);
+      await write();
+    });
+  } finally {
+    release();
+  }
+}
+var isRegistry = (value) => !!value && typeof value === "object" && ["put", "get", "has", "set"].every((k) => typeof value[k] === "function");
+var refChars = (ref) => parseInt(ref.slice(EDITOR_ASSET_PREFIX.length).split("-")[0], 36) || 0;
+function keptRefs(keep) {
+  const out = /* @__PURE__ */ new Set();
+  const addRegistry = (registry) => {
+    if (typeof registry.refs !== "function") {
+      throw new Error("A registry passed in keep cannot list its references (it has no refs()). Use createEditorAssetRegistry, or pass the documents to keep instead.");
+    }
+    for (const ref of registry.refs()) out.add(ref);
+  };
+  for (const item of keep) {
+    if (isRegistry(item)) addRegistry(item);
+    else if (item && typeof item === "object" && isRegistry(item.assets)) addRegistry(item.assets);
+    else for (const ref of collectAssetRefs(item)) out.add(ref);
+  }
+  return out;
+}
+async function collectEditorAssetGarbage(storage, options = {}) {
+  if (typeof storage.keys !== "function") {
+    throw new Error(
+      `This ${storage.kind} storage cannot list its keys, so unreferenced assets cannot be found. Give the adapter a keys(prefix) method (every built-in adapter has one).`
+    );
+  }
+  const listKeys = storage.keys.bind(storage);
+  const prefix = assetPrefix(options);
+  const keep = keptRefs(options.keep ?? []);
+  const dryRun = options.dryRun === true;
+  return withAssetLock(prefix, "exclusive", async () => {
+    const watch = watchAssetLeases();
+    try {
+      const assetKeys = (await listKeys(prefix)).filter((key) => ASSET_ID.test(key.slice(prefix.length)));
+      const others = (await listKeys("")).filter((key) => !key.startsWith(prefix));
+      const live = /* @__PURE__ */ new Set();
+      for (const key of others) {
+        const value = await storage.get(key);
+        if (value !== null && value.includes(EDITOR_ASSET_PREFIX)) for (const ref of collectAssetRefs(value)) live.add(ref);
+      }
+      const toRef = (key) => `${EDITOR_ASSET_PREFIX}${key.slice(prefix.length)}`;
+      let referenced = 0;
+      let kept = 0;
+      const candidates = [];
+      for (const key of assetKeys) {
+        const ref = toRef(key);
+        if (live.has(ref)) referenced++;
+        else if (keep.has(ref) || watch.touched.has(ref)) kept++;
+        else candidates.push(ref);
+      }
+      let unreferenced = candidates;
+      if (options.only) {
+        const wanted = new Set(options.only);
+        const stale = [...wanted].filter((ref) => !candidates.includes(ref));
+        if (stale.length) {
+          throw new Error(
+            `${stale.length} of the given asset${stale.length === 1 ? " is" : "s are"} not unreferenced in storage now (${stale.slice(0, 3).join(", ")}${stale.length > 3 ? ", \u2026" : ""}): unknown, already deleted, referenced or in use. Nothing was deleted; find the unreferenced assets again.`
+          );
+        }
+        unreferenced = candidates.filter((ref) => wanted.has(ref));
+      }
+      const report = {
+        assets: assetKeys.length,
+        scannedKeys: others.length,
+        referenced,
+        kept,
+        unreferenced,
+        unreferencedChars: unreferenced.reduce((n, ref) => n + refChars(ref), 0),
+        removed: [],
+        freedChars: 0,
+        dryRun
+      };
+      if (dryRun || !unreferenced.length) return report;
+      await storage.set(markerKey(options), `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`);
+      for (const ref of unreferenced) {
+        if (watch.touched.has(ref)) {
+          report.kept++;
+          continue;
+        }
+        try {
+          await storage.remove(assetKey(ref, options));
+        } catch (error) {
+          throw new Error(
+            `Deleted ${report.removed.length} of ${unreferenced.length} unreferenced assets, then storage failed: ${error instanceof Error ? error.message : String(error)}. The rest are still stored and nothing refers to the deleted ones; run the collection again.`
+          );
+        }
+        report.removed.push(ref);
+        report.freedChars += refChars(ref);
+      }
+      return report;
+    } finally {
+      watch.stop();
+    }
+  });
+}
+async function tryCollectEditorAssetGarbage(storage, options = {}) {
+  if (typeof storage.keys !== "function") return null;
+  try {
+    return await collectEditorAssetGarbage(storage, options);
+  } catch {
+    return null;
+  }
+}
+async function collectRetiredEditorAssets(storage, doc, setting = true) {
+  if (!doc.assets || setting === false) return null;
+  const extra = setting === true ? {} : setting;
+  let current;
+  try {
+    current = doc.getDocument();
+  } catch {
+    return null;
+  }
+  return tryCollectEditorAssetGarbage(storage, { ...extra, keep: [current, ...extra.keep ?? []] });
+}
 
 // src/persistence/migrate.ts
 function hasLoadProblems(report) {
@@ -378,6 +549,9 @@ export {
   persistEditorAssets,
   preloadEditorAssets,
   withEditorAssets,
+  collectEditorAssetGarbage,
+  tryCollectEditorAssetGarbage,
+  collectRetiredEditorAssets,
   hasLoadProblems,
   createLoadReport,
   migrateDocument,

package/dist/{chunk-5AARIS3R.cjs → chunk-XCDGM7TD.cjs}

@@ -18,7 +18,7 @@
 
 
 
-var _chunkJCXMJUQOcjs = require('./chunk-JCXMJUQO.cjs');
+var _chunkEGZM52EOcjs = require('./chunk-EGZM52EO.cjs');
 
 
 
@@ -29,7 +29,7 @@ var _chunkGF2RBSDMcjs = require('./chunk-GF2RBSDM.cjs');
 var _chunkDWJJI6RTcjs = require('./chunk-DWJJI6RT.cjs');
 
 
-var _chunkCIPIESX4cjs = require('./chunk-CIPIESX4.cjs');
+var _chunk4ZC5QJE2cjs = require('./chunk-4ZC5QJE2.cjs');
 
 // src/vector/blend.ts
 var lerpN = (a, b, t) => a + (b - a) * t;
@@ -37,7 +37,7 @@ var lerpP = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
 var toP = (v) => [v.x, v.y];
 var mapP = (m, p) => [m[0] * p[0] + m[2] * p[1] + m[4], m[1] * p[0] + m[3] * p[1] + m[5]];
 var curvesOf = (c) => Math.max(0, (c.pts.length - 1) / 3) | 0;
-function subpathToMorphContour(sp, m = _chunkJCXMJUQOcjs.IDENTITY_MATRIX) {
+function subpathToMorphContour(sp, m = _chunkEGZM52EOcjs.IDENTITY_MATRIX) {
   const n = sp.anchors.length;
   if (!n) return null;
   const first = mapP(m, toP(sp.anchors[0]));
@@ -67,8 +67,8 @@ function isStraight(p0, p1, p2, p3) {
   const u2 = along(p2);
   return off(p1) < tol && off(p2) < tol && u1 >= -1e-9 && u1 <= 1 + 1e-9 && u2 >= -1e-9 && u2 <= 1 + 1e-9;
 }
-function morphContourToSubpath(c, m = _chunkJCXMJUQOcjs.IDENTITY_MATRIX, closed = c.closed) {
-  const pts = _chunkJCXMJUQOcjs.isIdentityMatrix.call(void 0, m) ? c.pts : c.pts.map((p) => mapP(m, p));
+function morphContourToSubpath(c, m = _chunkEGZM52EOcjs.IDENTITY_MATRIX, closed = c.closed) {
+  const pts = _chunkEGZM52EOcjs.isIdentityMatrix.call(void 0, m) ? c.pts : c.pts.map((p) => mapP(m, p));
   const curves = curvesOf(c);
   const dropLast = closed && c.closed && curves > 0;
   const count = dropLast ? curves : curves + 1;
@@ -84,7 +84,7 @@ function morphContourToSubpath(c, m = _chunkJCXMJUQOcjs.IDENTITY_MATRIX, closed
     anchors[(k + 1) % count].in = { x: p2[0], y: p2[1] };
   }
   for (const a of anchors) {
-    const type = _chunkJCXMJUQOcjs.inferAnchorType.call(void 0, a);
+    const type = _chunkEGZM52EOcjs.inferAnchorType.call(void 0, a);
     if (type !== "corner") a.type = type;
   }
   const isClosed = closed && curves > 0;
@@ -267,7 +267,7 @@ function bestStart(fixed, free, useShapeContext) {
   return best;
 }
 function placeIn(c, from, to) {
-  const b = _chunkJCXMJUQOcjs.unionBounds.call(void 0, [boundsOfPoints(c.pts)]);
+  const b = _chunkEGZM52EOcjs.unionBounds.call(void 0, [boundsOfPoints(c.pts)]);
   const p = b ? [b.x + b.width / 2, b.y + b.height / 2] : c.pts[0];
   if (!from || !to) return p;
   const fx = from.width > 0 ? (p[0] - from.x) / from.width : 0.5;
@@ -452,11 +452,11 @@ function interpolateRigidMatrix(a, b, t) {
 function interpolateVectorColor(a, b, t) {
   if (t <= 0) return a;
   if (t >= 1) return b;
-  return _nullishCoalesce(_chunkCIPIESX4cjs.mixColorsOklab.call(void 0, a, b, t), () => ( (t < 0.5 ? a : b)));
+  return _nullishCoalesce(_chunk4ZC5QJE2cjs.mixColorsOklab.call(void 0, a, b, t), () => ( (t < 0.5 ? a : b)));
 }
 function resampleGradientStops(g, offsets) {
   return offsets.map((offset) => {
-    const s = _chunkJCXMJUQOcjs.sampleVectorGradient.call(void 0, g, offset);
+    const s = _chunkEGZM52EOcjs.sampleVectorGradient.call(void 0, g, offset);
     return s.opacity < 1 ? { offset, color: s.color, opacity: Math.round(s.opacity * 1e4) / 1e4 } : { offset, color: s.color };
   });
 }
@@ -467,11 +467,11 @@ function lerpAngle(a, b, t) {
 var lerpPoint = (a, b, t) => ({ x: lerpN(a.x, b.x, t), y: lerpN(a.y, b.y, t) });
 var sameColourModel = (a, b) => (_nullishCoalesce(a.interpolation, () => ( "srgb"))) === (_nullishCoalesce(b.interpolation, () => ( "srgb"))) && (_nullishCoalesce(a.smoothness, () => ( 0))) === (_nullishCoalesce(b.smoothness, () => ( 0)));
 function lerpStops(a, b, t) {
-  let stopsA = _chunkJCXMJUQOcjs.sortedVectorGradientStops.call(void 0, a);
-  let stopsB = _chunkJCXMJUQOcjs.sortedVectorGradientStops.call(void 0, b);
+  let stopsA = _chunkEGZM52EOcjs.sortedVectorGradientStops.call(void 0, a);
+  let stopsB = _chunkEGZM52EOcjs.sortedVectorGradientStops.call(void 0, b);
   const resampled = stopsA.length !== stopsB.length || !sameColourModel(a, b);
   if (resampled) {
-    const offs = [..._chunkJCXMJUQOcjs.expandVectorGradientStops.call(void 0, a), ..._chunkJCXMJUQOcjs.expandVectorGradientStops.call(void 0, b), ...stopsA, ...stopsB].map((s) => s.offset).filter(Number.isFinite).sort((x, y) => x - y);
+    const offs = [..._chunkEGZM52EOcjs.expandVectorGradientStops.call(void 0, a), ..._chunkEGZM52EOcjs.expandVectorGradientStops.call(void 0, b), ...stopsA, ...stopsB].map((s) => s.offset).filter(Number.isFinite).sort((x, y) => x - y);
     const common = offs.filter((o, i) => i === 0 || o - offs[i - 1] > 1e-4);
     stopsA = resampleGradientStops(a, common);
     stopsB = resampleGradientStops(b, common);
@@ -498,8 +498,8 @@ function lerpGradient(a, b, t) {
   }
   if (near.spread && near.spread !== "pad") out.spread = near.spread;
   if (near.strokeMode && near.strokeMode !== "within") out.strokeMode = near.strokeMode;
-  const ea = _chunkJCXMJUQOcjs.hasExplicitGradientGeometry.call(void 0, a);
-  const eb = _chunkJCXMJUQOcjs.hasExplicitGradientGeometry.call(void 0, b);
+  const ea = _chunkEGZM52EOcjs.hasExplicitGradientGeometry.call(void 0, a);
+  const eb = _chunkEGZM52EOcjs.hasExplicitGradientGeometry.call(void 0, b);
   if (!ea && !eb) {
     if (a.angle !== void 0 || b.angle !== void 0 || a.type === "linear" || a.type === "reflected") {
       const fallback = a.type === "linear" || a.type === "reflected" ? 180 : 90;
@@ -512,10 +512,10 @@ function lerpGradient(a, b, t) {
     }
     return out;
   }
-  const pa = _chunkJCXMJUQOcjs.vectorGradientPoints.call(void 0, a);
-  const pb = _chunkJCXMJUQOcjs.vectorGradientPoints.call(void 0, b);
+  const pa = _chunkEGZM52EOcjs.vectorGradientPoints.call(void 0, a);
+  const pb = _chunkEGZM52EOcjs.vectorGradientPoints.call(void 0, b);
   if (pa.units !== pb.units) {
-    const src = _chunkJCXMJUQOcjs.explicitVectorGradient.call(void 0, near);
+    const src = _chunkEGZM52EOcjs.explicitVectorGradient.call(void 0, near);
     return { ...src, stops: out.stops, ...out.interpolation ? { interpolation: out.interpolation } : {}, ...out.smoothness ? { smoothness: out.smoothness } : {} };
   }
   out.start = lerpPoint(pa.start, pb.start, t);
@@ -535,14 +535,14 @@ function solidLike(color, like) {
 function interpolateVectorPaint(a, b, t) {
   if (t <= 0) return a;
   if (t >= 1) return b;
-  const pa = _chunkJCXMJUQOcjs.hasPaint.call(void 0, a);
-  const pb = _chunkJCXMJUQOcjs.hasPaint.call(void 0, b);
+  const pa = _chunkEGZM52EOcjs.hasPaint.call(void 0, a);
+  const pb = _chunkEGZM52EOcjs.hasPaint.call(void 0, b);
   if (!pa && !pb) return t < 0.5 ? a : b;
   if (typeof a === "string" && pa && typeof b === "string" && pb) return interpolateVectorColor(a, b, t);
   if (!pa && typeof b === "string") return interpolateVectorColor("transparent", b, t);
   if (!pb && typeof a === "string") return interpolateVectorColor(a, "transparent", t);
-  const ga = pa && _chunkJCXMJUQOcjs.isVectorGradient.call(void 0, a) ? a : null;
-  const gb = pb && _chunkJCXMJUQOcjs.isVectorGradient.call(void 0, b) ? b : null;
+  const ga = pa && _chunkEGZM52EOcjs.isVectorGradient.call(void 0, a) ? a : null;
+  const gb = pb && _chunkEGZM52EOcjs.isVectorGradient.call(void 0, b) ? b : null;
   if (ga && gb) return _nullishCoalesce(lerpGradient(ga, gb, t), () => ( (t < 0.5 ? a : b)));
   if (gb) return _nullishCoalesce(lerpGradient(solidLike(pa ? a : null, gb), gb, t), () => ( b));
   if (ga) return _nullishCoalesce(lerpGradient(ga, solidLike(pb ? b : null, ga), t), () => ( a));
@@ -553,8 +553,8 @@ function interpolateWidthProfiles(a, b, t) {
   const at = [..._nullishCoalesce(a, () => ( [])), ..._nullishCoalesce(b, () => ( [])), { t: 0 }, { t: 1 }].map((p) => p.t).sort((x, y) => x - y);
   const ts = at.filter((v, i) => i === 0 || v - at[i - 1] > 1e-6);
   return ts.map((pos) => {
-    const x = _chunkJCXMJUQOcjs.widthProfileAt.call(void 0, a, pos);
-    const y = _chunkJCXMJUQOcjs.widthProfileAt.call(void 0, b, pos);
+    const x = _chunkEGZM52EOcjs.widthProfileAt.call(void 0, a, pos);
+    const y = _chunkEGZM52EOcjs.widthProfileAt.call(void 0, b, pos);
     return { t: pos, left: lerpN(x.left, y.left, t), right: lerpN(x.right, y.right, t) };
   });
 }
@@ -597,7 +597,7 @@ function reversedStyle(s) {
   out.endArrow = s.startArrow;
   out.startArrowScale = s.endArrowScale;
   out.endArrowScale = s.startArrowScale;
-  if (_optionalChain([s, 'access', _6 => _6.strokeWidthProfile, 'optionalAccess', _7 => _7.length])) out.strokeWidthProfile = _chunkJCXMJUQOcjs.reverseWidthProfile.call(void 0, s.strokeWidthProfile);
+  if (_optionalChain([s, 'access', _6 => _6.strokeWidthProfile, 'optionalAccess', _7 => _7.length])) out.strokeWidthProfile = _chunkEGZM52EOcjs.reverseWidthProfile.call(void 0, s.strokeWidthProfile);
   for (const k of ["startArrow", "endArrow", "startArrowScale", "endArrowScale"]) if (out[k] === void 0) delete out[k];
   return out;
 }
@@ -623,19 +623,19 @@ function styleOf(n) {
   return out;
 }
 function contoursOf(node, m) {
-  return _chunkJCXMJUQOcjs.expandVectorCorners.call(void 0, node.subpaths).map((sp) => subpathToMorphContour(sp, m)).filter((c) => !!c);
+  return _chunkEGZM52EOcjs.expandVectorCorners.call(void 0, node.subpaths).map((sp) => subpathToMorphContour(sp, m)).filter((c) => !!c);
 }
-function preparePathMorph(a, b, options, ma = _chunkJCXMJUQOcjs.nodeMatrix.call(void 0, a), mb = _chunkJCXMJUQOcjs.nodeMatrix.call(void 0, b)) {
+function preparePathMorph(a, b, options, ma = _chunkEGZM52EOcjs.nodeMatrix.call(void 0, a), mb = _chunkEGZM52EOcjs.nodeMatrix.call(void 0, b)) {
   const corr = correspondMorphContours(contoursOf(a, ma), contoursOf(b, mb), options);
   const sim = procrustes(corr.a, corr.b);
   const styleA = styleOf(a);
   const styleB = corr.reversed ? reversedStyle(styleOf(b)) : styleOf(b);
-  const rigid = !_chunkJCXMJUQOcjs.isIdentityMatrix.call(void 0, ma) || !_chunkJCXMJUQOcjs.isIdentityMatrix.call(void 0, mb);
+  const rigid = !_chunkEGZM52EOcjs.isIdentityMatrix.call(void 0, ma) || !_chunkEGZM52EOcjs.isIdentityMatrix.call(void 0, mb);
   const id = _nullishCoalesce(options.id, () => ( a.id));
   return (t) => {
     const contours = interpolateMorphContours(corr.a, corr.b, t, { linear: options.linear, rigidity: options.rigidity, similarity: sim });
-    const m = rigid ? interpolateRigidMatrix(ma, mb, t) : _chunkJCXMJUQOcjs.IDENTITY_MATRIX;
-    const back = rigid ? _chunkJCXMJUQOcjs.invertMatrix.call(void 0, m) : _chunkJCXMJUQOcjs.IDENTITY_MATRIX;
+    const m = rigid ? interpolateRigidMatrix(ma, mb, t) : _chunkEGZM52EOcjs.IDENTITY_MATRIX;
+    const back = rigid ? _chunkEGZM52EOcjs.invertMatrix.call(void 0, m) : _chunkEGZM52EOcjs.IDENTITY_MATRIX;
     const subpaths = contours.map((c, k) => {
       const closed = t <= 0 ? corr.a[k].closed : t >= 1 ? corr.b[k].closed : corr.a[k].closed && corr.b[k].closed;
       return morphContourToSubpath({ closed: corr.a[k].closed && corr.b[k].closed, pts: c.pts }, back, closed);
@@ -643,14 +643,14 @@ function preparePathMorph(a, b, options, ma = _chunkJCXMJUQOcjs.nodeMatrix.call(
     const node = { id, type: "path", subpaths, ...interpolateVectorStyle(styleA, styleB, t) };
     const opacity = lerpN(_nullishCoalesce(a.opacity, () => ( 1)), _nullishCoalesce(b.opacity, () => ( 1)), t);
     if (opacity < 1) node.opacity = opacity;
-    if (rigid && !_chunkJCXMJUQOcjs.isIdentityMatrix.call(void 0, m)) node.transform = m;
+    if (rigid && !_chunkEGZM52EOcjs.isIdentityMatrix.call(void 0, m)) node.transform = m;
     return node;
   };
 }
-function flattenPaths(node, parent = _chunkJCXMJUQOcjs.IDENTITY_MATRIX) {
-  const m = _chunkJCXMJUQOcjs.multiplyMatrices.call(void 0, _chunkJCXMJUQOcjs.nodeMatrix.call(void 0, node), parent);
+function flattenPaths(node, parent = _chunkEGZM52EOcjs.IDENTITY_MATRIX) {
+  const m = _chunkEGZM52EOcjs.multiplyMatrices.call(void 0, _chunkEGZM52EOcjs.nodeMatrix.call(void 0, node), parent);
   if (node.type === "path") return [{ path: node, m, opacity: 1 }];
-  if (node.type === "text" || node.type === "instance") return flattenPaths(_chunkJCXMJUQOcjs.expandVectorAppearance.call(void 0, node), parent);
+  if (node.type === "text" || node.type === "instance") return flattenPaths(_chunkEGZM52EOcjs.expandVectorAppearance.call(void 0, node), parent);
   const o = _nullishCoalesce(node.opacity, () => ( 1));
   return node.children.filter((c) => c.visible !== false).flatMap((c) => flattenPaths(c, m)).map((e) => ({ ...e, opacity: e.opacity * o }));
 }
@@ -672,8 +672,8 @@ function createVectorMorph(a, b, options = {}) {
   }
   const pa = flattenPaths(a);
   const pb = flattenPaths(b);
-  const ba = _chunkJCXMJUQOcjs.unionBounds.call(void 0, pa.map((e) => placedBounds(e.path, e.m)));
-  const bb = _chunkJCXMJUQOcjs.unionBounds.call(void 0, pb.map((e) => placedBounds(e.path, e.m)));
+  const ba = _chunkEGZM52EOcjs.unionBounds.call(void 0, pa.map((e) => placedBounds(e.path, e.m)));
+  const bb = _chunkEGZM52EOcjs.unionBounds.call(void 0, pb.map((e) => placedBounds(e.path, e.m)));
   const id = _nullishCoalesce(options.id, () => ( a.id));
   const parts = [];
   const opacities = [];
@@ -685,10 +685,10 @@ function createVectorMorph(a, b, options = {}) {
       parts.push(preparePathMorph(x.path, y.path, sub, x.m, y.m));
       opacities.push([x.opacity, y.opacity]);
     } else if (x) {
-      parts.push(preparePathMorph(x.path, collapsedPath(x.path, x.m, ba, bb), sub, x.m, _chunkJCXMJUQOcjs.IDENTITY_MATRIX));
+      parts.push(preparePathMorph(x.path, collapsedPath(x.path, x.m, ba, bb), sub, x.m, _chunkEGZM52EOcjs.IDENTITY_MATRIX));
       opacities.push([x.opacity, x.opacity]);
     } else if (y) {
-      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub, _chunkJCXMJUQOcjs.IDENTITY_MATRIX, y.m));
+      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub, _chunkEGZM52EOcjs.IDENTITY_MATRIX, y.m));
       opacities.push([y.opacity, y.opacity]);
     }
   }

package/dist/{chunk-EVXQNQND.js → chunk-XZB3TJ6K.js}

@@ -253,6 +253,12 @@ var ToolRegistryView = class {
       return set.tools.some((t) => this.enabledTools.has(t)) ? "some" : "none";
     };
     const listedCount = () => this.listed(this.catalogue()).length;
+    const styleOf = async (set) => {
+      const domain = set.skill?.replace(/^pixerate-/, "");
+      if (!discovery.styles || !domain || !discovery.styles.domains.some((d) => d.id === domain)) return void 0;
+      const style = await discovery.styles.resolve(domain);
+      return style.skills.length ? { domain, skills: style.skills.length, layers: [...new Set(style.skills.map((s) => s.layer))] } : void 0;
+    };
     const tools = [
       {
         name: "list_toolsets",
@@ -260,16 +266,18 @@ var ToolRegistryView = class {
         description: "Lists the groups of editor tools available here (one per open editor or feature): name, title, what it covers, its agent skill, how many tools it has and whether they are in your tool list (`enabled`: all, some or none). Start here, then call search_tools or enable_tools.",
         annotations: READ_ONLY,
         inputSchema: { type: "object", properties: {}, additionalProperties: false },
-        handler: () => {
+        handler: async () => {
           const cat = this.catalogue();
+          const styles = await Promise.all(cat.sets.map(styleOf));
           return {
-            toolsets: cat.sets.map((set) => ({
+            toolsets: cat.sets.map((set, i) => ({
               name: set.name,
               ...set.title ? { title: set.title } : {},
               ...set.description ? { description: set.description } : {},
               ...set.skill ? { skill: set.skill } : {},
               tools: set.tools.length,
-              enabled: enabledState(set)
+              enabled: enabledState(set),
+              ...styles[i] ? { style: styles[i] } : {}
             })),
             ...skills.length > 0 ? { skills: skills.map((s) => s.name) } : {}
           };
@@ -312,9 +320,12 @@ var ToolRegistryView = class {
         description: "Adds tools to your tool list: single tools by name (from search_tools) and/or whole toolsets (from list_toolsets). Returns the names added and how many tools are listed now. Prefer single tools over large toolsets. Unknown names fail and change nothing.",
         annotations: LISTING,
         inputSchema: SELECTION_SCHEMA,
-        handler: (args) => {
+        handler: async (args) => {
           const added = this.enableTools(args);
-          return { added, listed: listedCount() };
+          const sets = this.catalogue().sets.filter((set) => set.tools.some((t) => added.includes(t)));
+          const domains = (await Promise.all(sets.map(styleOf))).filter((s) => s !== void 0).map((s) => s.domain);
+          const style = [...new Set(domains)].map((d) => `House style applies: call get_style with domain "${d}" before making changes.`);
+          return { added, listed: listedCount(), ...style.length ? { style } : {} };
         }
       },
       {

package/dist/chunk-YBAPT7NL.js

@@ -0,0 +1,153 @@
+import {
+  contrastLevel,
+  contrastRatio,
+  linearSrgbToDisplayP3,
+  linearToSrgb,
+  oklabToOklch,
+  oklabToRgb,
+  oklchToOklab,
+  parseColor,
+  rgbToHsl,
+  rgbToOklab,
+  srgbToLinear
+} from "./chunk-MHLU6GRJ.js";
+
+// src/color/gamut.ts
+var clamp01 = (v) => Math.min(1, Math.max(0, v));
+function inSrgbGamut(c, epsilon = 1e-5) {
+  return c.r >= -epsilon && c.r <= 1 + epsilon && c.g >= -epsilon && c.g <= 1 + epsilon && c.b >= -epsilon && c.b <= 1 + epsilon;
+}
+function deltaEOK(a, b) {
+  const la = rgbToOklab(a);
+  const lb = rgbToOklab(b);
+  return Math.hypot(la.l - lb.l, la.a - lb.a, la.b - lb.b);
+}
+function toSrgbGamut(c) {
+  const lch = oklabToOklch(rgbToOklab(c));
+  if (lch.l >= 1) return { r: 1, g: 1, b: 1, a: c.a };
+  if (lch.l <= 0) return { r: 0, g: 0, b: 0, a: c.a };
+  if (inSrgbGamut(c)) {
+    return { r: clamp01(c.r), g: clamp01(c.g), b: clamp01(c.b), a: c.a };
+  }
+  let low = 0;
+  let high = lch.c;
+  let clippedCandidate = { r: clamp01(c.r), g: clamp01(c.g), b: clamp01(c.b), a: c.a };
+  const JND = 0.02;
+  const EPS = 1e-4;
+  for (let i = 0; i < 30; i++) {
+    const mid = (low + high) / 2;
+    const candidate = oklabToRgb(oklchToOklab({ l: lch.l, c: mid, h: lch.h, alpha: c.a }));
+    const clipped = {
+      r: clamp01(candidate.r),
+      g: clamp01(candidate.g),
+      b: clamp01(candidate.b),
+      a: c.a
+    };
+    clippedCandidate = clipped;
+    const dE = deltaEOK(candidate, clipped);
+    if (dE < JND) {
+      if (JND - dE < EPS) {
+        return clipped;
+      }
+      low = mid;
+    } else {
+      high = mid;
+    }
+    if (high - low < 1e-4) {
+      break;
+    }
+  }
+  return clippedCandidate;
+}
+
+// src/color/format.ts
+var clamp012 = (v) => Math.min(1, Math.max(0, v));
+var byte = (v) => Math.round(clamp012(v) * 255);
+var hex2 = (n) => n.toString(16).padStart(2, "0");
+var round2 = (n) => (Math.round(n * 100) / 100).toString();
+function formatHex(c) {
+  const mapped = toSrgbGamut(c);
+  const head = `#${hex2(byte(mapped.r))}${hex2(byte(mapped.g))}${hex2(byte(mapped.b))}`;
+  const alpha = byte(mapped.a);
+  return alpha === 255 ? head : head + hex2(alpha);
+}
+function formatColor(c, format) {
+  switch (format) {
+    case "hex":
+      return formatHex(c);
+    case "rgb": {
+      const inGamut = toSrgbGamut(c);
+      const r = byte(inGamut.r);
+      const g = byte(inGamut.g);
+      const b = byte(inGamut.b);
+      return c.a < 1 ? `rgb(${r} ${g} ${b} / ${round2(c.a)})` : `rgb(${r} ${g} ${b})`;
+    }
+    case "hsl": {
+      const hsl = rgbToHsl(toSrgbGamut(c));
+      const h = (Math.round(hsl.h * 100) / 100).toString();
+      const s = (Math.round(hsl.s * 1e4) / 100).toString();
+      const l = (Math.round(hsl.l * 1e4) / 100).toString();
+      return c.a < 1 ? `hsl(${h} ${s}% ${l}% / ${round2(c.a)})` : `hsl(${h} ${s}% ${l}%)`;
+    }
+    case "oklch": {
+      const lch = oklabToOklch(rgbToOklab(c));
+      const l = (lch.l * 100).toFixed(2);
+      const ch = lch.c.toFixed(4);
+      const h = lch.h.toFixed(2);
+      return c.a < 1 ? `oklch(${l}% ${ch} ${h} / ${round2(c.a)})` : `oklch(${l}% ${ch} ${h})`;
+    }
+    case "oklab": {
+      const lab = rgbToOklab(c);
+      const l = (lab.l * 100).toFixed(2);
+      const a = lab.a.toFixed(4);
+      const b = lab.b.toFixed(4);
+      return c.a < 1 ? `oklab(${l}% ${a} ${b} / ${round2(c.a)})` : `oklab(${l}% ${a} ${b})`;
+    }
+    case "p3": {
+      const linSrgb = {
+        r: srgbToLinear(c.r),
+        g: srgbToLinear(c.g),
+        b: srgbToLinear(c.b),
+        a: c.a
+      };
+      const linP3 = linearSrgbToDisplayP3(linSrgb);
+      const r = linearToSrgb(linP3.r).toFixed(4);
+      const g = linearToSrgb(linP3.g).toFixed(4);
+      const b = linearToSrgb(linP3.b).toFixed(4);
+      return c.a < 1 ? `color(display-p3 ${r} ${g} ${b} / ${round2(c.a)})` : `color(display-p3 ${r} ${g} ${b})`;
+    }
+  }
+}
+function normalizeColor(input) {
+  const parsed = parseColor(input);
+  return parsed ? formatHex(parsed) : null;
+}
+
+// src/color/suggest.ts
+function suggestAccessibleForeground(foreground, background, options = {}) {
+  const large = options.large ?? false;
+  const lch = oklabToOklch(rgbToOklab(foreground));
+  const asHex = (l) => parseColor(formatHex(toSrgbGamut(oklabToRgb(oklchToOklab({ ...lch, l })))));
+  for (let d = 0.01; d <= 1; d += 0.01) {
+    const downCand = asHex(Math.max(0, lch.l - d));
+    const upCand = asHex(Math.min(1, lch.l + d));
+    const downRatio = contrastRatio(downCand, background);
+    const upRatio = contrastRatio(upCand, background);
+    const downPass = contrastLevel(downRatio, { large }) !== "fail";
+    const upPass = contrastLevel(upRatio, { large }) !== "fail";
+    if (downPass && upPass) return formatHex(downRatio >= upRatio ? downCand : upCand);
+    if (downPass) return formatHex(downCand);
+    if (upPass) return formatHex(upCand);
+  }
+  return void 0;
+}
+
+export {
+  inSrgbGamut,
+  deltaEOK,
+  toSrgbGamut,
+  formatHex,
+  formatColor,
+  normalizeColor,
+  suggestAccessibleForeground
+};