@panphora/clayjs 1.15.2 → 1.17.0

package/src/plugins/live.js

@@ -8,20 +8,21 @@
 import { contains, parseBy, frameSet, descendants, unionRanges, formatBy } from "../live/provenance.js";
 import { createStore } from "../live/store.js";
 import { serializeLive, stampOf, parseStamp, textHash } from "../live/ops.js";
-import { onSnapshot } from "../core/snapshot.js";
+import { capturePageState, onSnapshot } from "../core/snapshot.js";
 import { onSaveAccepted, onSaveAttempt, onSaveOutcome, isSaveInProgress } from "../core/save-core.js";
 import { savePageForce, baselineSettled, isSaveConflicted, autosaveIsSuspended } from "../core/save.js";
 import { withKeepalive } from "../core/save-core.js";
 import { isEditMode } from "../core/is-edit-mode.js";
 import { registerUnsavedState } from "../lib/unsaved-state.js";
 import { createCheckpoints } from "../live/checkpoint.js";
-import { HyperMorph } from "../vendor/hyper-morph.vendor.js";
+import { parseJsonRelaxed } from "../vendor/hyper-morph-json.vendor.js";
 import * as hostMeta from "../core/host-meta.js";
 import { createFastLane } from "../live/fast-lane.js";
 import { createSaveHistoryRecovery, RECOVERY_WINDOW_MS } from "../live/save-history.js";
 import { serverTransport } from "../live/server-lane.js";
 import { localTransport, localLaneSupported } from "../live/local-lane.js";
 import { captureYValue } from "../page/ybind/parts.js";
+import { lastSeenEtag, recordEtag } from "../core/etag.js";
 
 const NAME = /^[A-Za-z0-9_.:-]{1,64}$/;
 const entries = new Map();
@@ -406,17 +407,25 @@ function sortedKeys(value) {
 
 function canonical(text) {
   try {
-    return JSON.stringify(sortedKeys(HyperMorph.parseJsonRelaxed(text)));
+    return JSON.stringify(sortedKeys(parseJsonRelaxed(text)));
   } catch {
     return null;
   }
 }
 
+// The writer session a mode lease owns (see liveWriterParticipant). Null until one is
+// prepared, and null again once it is disposed: a page whose loader has not registered
+// a writer keeps the old rule, one lane per edit-mode tab. While a session has closed
+// admission (entry preparing, or an exit draining what this tab still holds) no local
+// op is framed and no checkpoint saves.
+let writerSession = null;
+const writerAdmitted = () => !writerSession || writerSession.admitted;
+
 // Saved stores with changes no accepted save holds yet. Only an edit-mode tab
 // saves. In file mode that is this tab's unconfirmed ops; in fast mode the room
 // says the file does not reach its latest change, and only the writer saves.
 function unsavedLiveChanges() {
-  if (!isEditMode) return false;
+  if (!isEditMode || !writerAdmitted()) return false;
   for (const entry of entries.values()) {
     if (entry.store.ephemeral) continue;
     if (entry.store.handle.status.mode === "fast") {
@@ -437,7 +446,7 @@ function fileMoved() {
 
 const checkpoints = createCheckpoints({
   needsSave: unsavedLiveChanges,
-  blocked: () => !baselineSettled() || isSaveConflicted() || autosaveIsSuspended() || historyPending(),
+  blocked: () => !writerAdmitted() || !baselineSettled() || isSaveConflicted() || autosaveIsSuspended() || historyPending(),
   save: () => savePageForce().finally(fileMoved),
   saveNow: () => withKeepalive(true, () => savePageForce()),
 });
@@ -446,6 +455,9 @@ const checkpoints = createCheckpoints({
 // clay.live() call in an edit-mode tab.
 let fast = null;
 let laneRequested = false;
+// Bumped by every request and every release, so an answer that arrives after its
+// session was released starts nothing.
+let laneRequest = 0;
 let serverLane = null;
 // The host merges exact save provenance (live-by v2); without it a save that
 // needs provenance is refused rather than risk applying an edit twice.
@@ -455,6 +467,144 @@ let local = null;
 // forward): only a closing page's save is reported to the local room at capture.
 let closing = false;
 
+// A listener for the store behind a session: a reader's tag, and the values other
+// tabs saved to it, keep following the file.
+function sessionStores() {
+  return [...entries.values()].filter((entry) => !entry.store.ephemeral);
+}
+
+// What this tab still holds that the page's own bytes cannot carry: ops a store in a
+// room has not had acknowledged. A reader's own change is not one of them.
+function liveWriterPending() {
+  if (!writerSession || writerSession.admitted || !fast || fast.status.stopped) return false;
+  for (const entry of sessionStores()) {
+    if (entry.store.handle.status.mode === "fast" && entry.store.pending.length > 0) return true;
+  }
+  return false;
+}
+
+// Frame what the lane has not sent and wait for the room to take it. This is the one
+// transfer that lets the writer be released: a checkpoint writes the room's value, so
+// an unacknowledged op of this tab has to travel through the room, not the file.
+export async function drainLiveWriter({ timeoutMs = 5000 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  const frame = () => {
+    for (const entry of sessionStores()) {
+      if (entry.store.handle.status.mode !== "fast") continue;
+      if (entry.store.pending.length > 0) fast?.release(entry.store.name);
+    }
+  };
+  frame();
+  while (liveWriterPending()) {
+    if (Date.now() >= deadline) return { ok: false, code: "timeout" };
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    frame();
+  }
+  return { ok: true };
+}
+
+registerUnsavedState({ id: "live:writer", isPending: liveWriterPending, flush: drainLiveWriter });
+
+// The lane a session starts from: the reader's own ops are not this session's edits,
+// and no position a previous session's lane reported is carried into this one.
+function resetWriterSession() {
+  for (const entry of entries.values()) {
+    entry.framesSince = false;
+    const ids = entry.store.pendingEntries().map((item) => item.id);
+    if (ids.length) entry.store.rebase(entry.store.authoritative, { source: "state", dropIds: ids });
+  }
+}
+
+// Give back everything the lane holds: the transport's subscription (its stream
+// handlers and its local channel), the room position, and the request for a lane, so
+// the next session starts a fresh one.
+function releaseWriter() {
+  const lane = fast;
+  fast = null;
+  laneRequested = false;
+  laneRequest++;
+  serverLane = null;
+  local = null;
+  provenanceHost = false;
+  // The gates went with the lane: a second entry must not read this released one as ready.
+  laneReady = null;
+  writerReady = null;
+  settleLane = null;
+  settleWriter = null;
+  lane?.stop();
+}
+
+/**
+ * clay.live as a mode participant: the store's writer, started by the commit that
+ * enters edit and released by the one that leaves it.
+ *
+ * `prepare` closes admission and puts the stores back on the reader's value, so
+ * nothing a reader changed can be uploaded as this person's edit. `enable` starts
+ * the tab's lane. `quiesce` closes admission again and drains the ops the room has
+ * not acknowledged, so a refused exit resumes the very same lane. `dispose` (after the
+ * barrier) stops the lane and forgets its subscription, its room and its send queue.
+ */
+export function liveWriterParticipant() {
+  return {
+    id: "clay:live",
+    order: 200,
+    prepare(context = {}) {
+      // An adoption is the session this tab's edit boot started: the exit takes that one
+      // back, and the entry asks for no second lane.
+      if (context.initial === true) {
+        if (!writerSession) writerSession = { admitted: true };
+        return writerLease(writerSession, { adopted: true });
+      }
+      freshLaneGates();
+      // The lane's transport opens with the preparation, not with the commit: the page
+      // (order 400) waits on the room while it prepares, and it prepares before any
+      // enable runs. Admission is still the commit's, so what a person does is what
+      // reaches the room.
+      const session = { admitted: false, wantsLane: true };
+      writerSession = session;
+      resetWriterSession();
+      ensureLane();
+      return writerLease(session);
+    },
+  };
+}
+
+function releaseHeld() {
+  for (const entry of sessionStores()) {
+    if (entry.store.pending.length > 0) fast?.release(entry.store.name);
+  }
+}
+
+function writerLease(session, { adopted = false } = {}) {
+  return {
+    enable() {
+      if (adopted || writerSession !== session) return;
+      session.admitted = true;
+      ensureLane();
+      // A lane opened at preparation may already hold ops the page made before the
+      // commit (an adoption's), which onLocal kept back while admission was closed.
+      releaseHeld();
+    },
+    quiesce() {
+      if (writerSession !== session) return;
+      session.admitted = false;
+      return drainLiveWriter();
+    },
+    resume() {
+      if (writerSession !== session) return;
+      session.admitted = true;
+      releaseHeld();
+    },
+    dispose() {
+      if (writerSession !== session) return;
+      writerSession = null;
+      releaseWriter();
+    },
+  };
+}
+
+export { liveWriterParticipant as modeParticipant };
+
 // The page plugin's one-shot gates: the fast lane's setup, and the room's
 // writer election. Both resolve null when this tab has no lane at all.
 let laneReady = null;
@@ -462,11 +612,15 @@ let writerReady = null;
 let settleLane = null;
 let settleWriter = null;
 
+// A fresh pair for a new session: the page plugin awaits these, and the ones a released
+// session settled answer for a lane that no longer exists.
+function freshLaneGates() {
+  laneReady = new Promise((resolve) => { settleLane = resolve; });
+  writerReady = new Promise((resolve) => { settleWriter = resolve; });
+}
+
 function laneGates() {
-  if (!laneReady) {
-    laneReady = new Promise((resolve) => { settleLane = resolve; });
-    writerReady = new Promise((resolve) => { settleWriter = resolve; });
-  }
+  if (!laneReady) freshLaneGates();
   return { laneReady, writerReady };
 }
 
@@ -597,7 +751,7 @@ function seedLocalRoom() {
       continue;
     }
     try {
-      const value = HyperMorph.parseJsonRelaxed(tag.element.textContent);
+      const value = parseJsonRelaxed(tag.element.textContent);
       if (value !== null && typeof value === "object") values.set(name, { value, ephemeral: tag.ephemeral });
     } catch {}
   }
@@ -606,17 +760,21 @@ function seedLocalRoom() {
 
 function ensureLane() {
   laneGates();
-  if (laneRequested || !isEditMode) return;
+  if (laneRequested || !(writerSession ? writerSession.admitted || writerSession.wantsLane : isEditMode)) return;
   laneRequested = true;
+  const request = ++laneRequest;
   hostMeta.hostSupports("live-data").then(
     async (supported) => {
       const provenance = supported && (await hostMeta.hostSupports("live-provenance"));
+      if (request !== laneRequest) return;
       serverLane = supported;
       provenanceHost = provenance;
       if (supported) {
         fast = createFastLane(laneOptions(serverTransport()));
       } else if (localLaneSupported()) {
-        local = localTransport({ seed: seedLocalRoom });
+        // The document's own floor picks the channel scope: a floor-1 document
+        // never shares the lane a tab that cannot read it is on.
+        local = localTransport({ seed: seedLocalRoom, floor: document.querySelector('meta[name="clay-page-format"]')?.getAttribute("content") });
         fast = createFastLane(laneOptions(local));
       } else {
         settleLane?.(null);
@@ -707,7 +865,7 @@ export function serializeLines(value) {
 // already holds (its frames that landed before the value's stamp).
 function hashOfText(text) {
   try {
-    return textHash(serializeLive(HyperMorph.parseJsonRelaxed(text)));
+    return textHash(serializeLive(parseJsonRelaxed(text)));
   } catch {
     return null;
   }
@@ -716,28 +874,16 @@ function hashOfText(text) {
 function receive(entry, text, source, dropIds) {
   let value;
   try {
-    value = HyperMorph.parseJsonRelaxed(text);
+    value = parseJsonRelaxed(text);
   } catch {
     return;
   }
   if (entry.store.rebase(value, { source, ...(dropIds?.length && { dropIds }) })) entry.framesSince = true;
 }
 
-export function live(name) {
-  const existing = entries.get(name);
-  if (existing) return existing.store.handle;
-  const tag = liveTags().get(name);
-  if (!tag) throw new Error(`clay.live: this page has no <script type="application/json" merge="${name}" clay="live"> tag`);
-  const text = tag.element.textContent;
-  let value;
-  try {
-    value = HyperMorph.parseJsonRelaxed(text);
-  } catch (err) {
-    throw new SyntaxError(`clay.live("${name}"): the tag's JSON does not parse: ${err.message}`);
-  }
-  const store = createStore({ name, value, ephemeral: tag.ephemeral });
-  const layout = tag.element.getAttribute("live-format") === "lines" ? "lines" : text.includes("\n") ? "pretty" : "line";
-  const entry = { store, layout, framesSince: false, last: 0, landed: 0, leftAt: lineageOf(tag.element), captureOps: new Map(), withheld: false, reading: false, timer: null, recovery: null, historicalRefreshPending: false, refreshTimer: null };
+// One open store and what the plugin follows about it. A staged store has no lane.
+function openEntry(name, store, { layout = "line", leftAt = null, staged = null } = {}) {
+  const entry = { store, layout, framesSince: false, last: 0, landed: 0, leftAt, captureOps: new Map(), withheld: false, reading: false, timer: null, recovery: null, historicalRefreshPending: false, refreshTimer: null, staged };
   entries.set(name, entry);
   store.onDelivery((event) => {
     if (event.code === "receipt-expired") document.dispatchEvent(new CustomEvent("clay:live-notice", {
@@ -756,14 +902,79 @@ export function live(name) {
     settle(entry);
     if (store.handle.status.mode === "file" && ["undone", "refused", "decided"].includes(event.cause)) entry.leftAt = null;
   });
-  if (!tag.ephemeral) store.onLocal(() => checkpoints.changed());
-  store.onLocal((ops) => fast?.local(name, ops, store.mark));
+  if (!store.ephemeral) store.onLocal(() => checkpoints.changed());
+  store.onLocal((ops) => { if (!entry.staged && writerAdmitted()) fast?.local(name, ops, store.mark); });
   store.handle.on("change", () => {
     if (!store.ephemeral && store.handle.status.mode === "fast") checkpoints.changed();
   });
-  fast?.storeOpened(name);
+  if (!staged) {
+    fast?.storeOpened(name);
+    ensureLane();
+  }
+  return entry;
+}
+
+export function live(name) {
+  const existing = entries.get(name);
+  if (existing) return existing.store.handle;
+  const tag = liveTags().get(name);
+  if (!tag) throw new Error(`clay.live: this page has no <script type="application/json" merge="${name}" clay="live"> tag`);
+  const text = tag.element.textContent;
+  let value;
+  try {
+    value = parseJsonRelaxed(text);
+  } catch (err) {
+    throw new SyntaxError(`clay.live("${name}"): the tag's JSON does not parse: ${err.message}`);
+  }
+  const store = createStore({ name, value, ephemeral: tag.ephemeral });
+  const layout = tag.element.getAttribute("live-format") === "lines" ? "lines" : text.includes("\n") ? "pretty" : "line";
+  const entry = openEntry(name, store, { layout, leftAt: lineageOf(tag.element) });
+  return entry.store.handle;
+}
+
+// A page whose file carries no state of its own yet: the seed in memory, no tag in
+// the document, no request, until its first genuine op is written by the ordinary
+// save. Only an accepted write opens its room.
+export function stageStore(name, { value, represented = null, signal = null } = {}) {
+  const existing = entries.get(name);
+  if (existing && !existing.staged) throw new Error(`clay.live("${name}"): the store is open in a room`);
+  const entry = existing ?? openEntry(name, createStore({ name, value, ephemeral: false }), { staged: { represented, signal } });
+  return {
+    handle: entry.store.handle,
+    isPending: () => !!entry.staged && entry.store.pending.length > 0,
+    flush: (options = {}) => flushStaged(entry, options),
+    dispose() {
+      if (entry.staged && entries.get(name) === entry) entries.delete(name);
+    },
+    // The session that staged this store is over, whether or not its first write was
+    // accepted: the room keeps the value, and the next session stages its own from the
+    // bytes it represents.
+    close() {
+      if (entries.get(name) === entry) entries.delete(name);
+    },
+  };
+}
+
+// The first write, through the save this tab would make anyway.
+async function flushStaged(entry, { timeoutMs = 10_000 } = {}) {
+  const staged = entry.staged;
+  if (!staged || !entry.store.pending.length) return { ok: true };
+  if (staged.conflict) return { ok: false, code: staged.conflict };
+  const at = staged.represented?.etag || null;
+  const held = lastSeenEtag();
+  if (at && held && at !== held) return { ok: false, code: "stale-document" };
+  if (at && !held) recordEtag(at);
+  const result = await requestCheckpoint({ timeoutMs });
+  return result.ok ? { ok: true } : { ok: false, code: staged.conflict ?? result.code ?? null };
+}
+
+function activateStaged(entry) {
+  if (!entry.staged) return;
+  entry.staged = null;
+  // Its file had no tag and the live page never gets one: every later capture builds it.
+  entry.tagless = true;
+  fast?.storeOpened(entry.store.name);
   ensureLane();
-  return store.handle;
 }
 
 // Every capture carries each saved store's current value. A never-saved store
@@ -773,7 +984,19 @@ onSnapshot((clone, { forSave, requestRefresh }) => {
   const tags = liveTags(clone, { warn: false });
   for (const entry of entries.values()) {
     if (entry.store.ephemeral) continue;
-    const tag = tags.get(entry.store.name);
+    let tag = tags.get(entry.store.name);
+    // A staged store reaches the file here, where the boot would have put its tag, and
+    // so does one that started that way, on every save after its first.
+    if (!tag && (entry.staged || entry.tagless)) {
+      const article = clone.querySelector("article[data-page]");
+      if (!article) continue;
+      const element = article.ownerDocument.createElement("script");
+      element.setAttribute("type", "application/json");
+      element.setAttribute("merge", entry.store.name);
+      element.setAttribute("clay", "live");
+      article.parentNode.insertBefore(element, article);
+      tag = { name: entry.store.name, ephemeral: false, element };
+    }
     if (!tag) continue;
     // A recovering store's own operations are not written again while the answer
     // about them is still open, and not before the value the file holds now has
@@ -936,6 +1159,7 @@ function confirmPin(html, pin) {
     } else {
       entry.store.confirm(saved.mark);
       entry.leftAt = saved.lineage && tag.element.getAttribute("live-by") === saved.by ? saved.lineage : { disk: true };
+      activateStaged(entry);
     }
     settle(entry);
   }
@@ -992,6 +1216,17 @@ onSaveOutcome(({ captureId, result, attempts, sent }) => {
   if (result?.ok) return;
   const pin = capturePins.get(captureId);
   if (!pin) return;
+  const stagedEntry = [...pin.keys()].map((name) => entries.get(name)).find((entry) => entry?.staged);
+  // Nothing was written: the staged store is clean and nothing follows.
+  if (stagedEntry && result.code === "page-nothing-to-write") {
+    stagedEntry.store.confirm(stagedEntry.store.mark);
+    dropCapture(captureId);
+    releaseBody();
+    settle(stagedEntry);
+    return;
+  }
+  // This tab's value does not descend from the stored document: never send it again.
+  if (stagedEntry && result.code === "page-lineage-stale") stagedEntry.staged.conflict = "conflict";
   dropCapture(captureId);
   const landed = mayHaveLanded(result, sent);
   const plan = landed ? historyPlan(captureId) : null;
@@ -1000,11 +1235,47 @@ onSaveOutcome(({ captureId, result, attempts, sent }) => {
   if (plan) startHistoryRecovery(plan, { result, attempts, startedAt: Date.now() });
 });
 
+// The recovery integration's turn at an accepted save, when one journals this page.
+// Registered by page code once it holds a `page.yjs` channel, so a page that journals
+// nothing loads neither the proof builder nor the conditional client, and pays one null
+// check per save.
+let pageCheckpoints = null;
+
+/**
+ * Hand every accepted save to a page checkpoint integration, or null to stop.
+ *
+ * The integration builds the proof from the capture's pinned page state and the bytes
+ * the host took; nothing here decides what is covered. Its answer is not awaited: a save
+ * that succeeded is saved whether or not a journal can be retired, and a failure there
+ * must never reach the save's own outcome.
+ *
+ * @param {?Function} install - ({capture, state, article, etag}) => unknown
+ */
+export function registerPageCheckpoints(install) {
+  pageCheckpoints = install;
+}
+
+function offerCheckpoint(captureId, html) {
+  if (!pageCheckpoints) return;
+  // Read synchronously, before this capture is released: the value is the one its page
+  // tag carried, and the edits that followed it are not in these bytes.
+  const state = capturePageState(captureId);
+  if (!state) return;
+  let article = null;
+  try { article = parseHtml(html).querySelector("article[data-page]")?.innerHTML ?? null; }
+  catch (_) { article = null; }
+  const etag = lastSeenEtag();
+  Promise.resolve()
+    .then(() => pageCheckpoints({ capture: String(captureId), state, article, etag }))
+    .catch(() => {});
+}
+
 // An accepted body confirms the ops of the capture that sent it, and only those.
 // A null context (a raw save) cannot consume a captured pin.
 function handleAccepted(html, context) {
   const captureId = context?.captureId;
   if (captureId === null || captureId === undefined) return;
+  offerCheckpoint(captureId, html);
   const pin = capturePins.get(captureId);
   if (!pin) return;
   dropCapture(captureId);
@@ -1088,6 +1359,8 @@ export function receiveFrame(html, seq = null) {
       else if (pageTag.getAttribute("live-by") !== by) pageTag.setAttribute("live-by", by);
     }
     if (entry && !entry.store.ephemeral) {
+      // An old seed is never merged into a newer article before its first write.
+      if (entry.staged) continue;
       if (entry.store.handle.status.mode === "file") receive(entry, text, "remote", dropIds);
       continue;
     }
@@ -1100,10 +1373,13 @@ document.addEventListener("clay:sync-applied", (event) => receiveFrame(event.det
 // The last chance to save live changes made since the previous checkpoint. A
 // keepalive body is capped near 60 KB; a larger page's save may not finish.
 document.addEventListener("visibilitychange", () => {
-  if (document.visibilityState === "hidden") checkpoints.flush();
+  if (document.visibilityState === "hidden" && isEditMode && writerAdmitted()) checkpoints.flush();
 });
 window.addEventListener("pagehide", () => {
   closing = true;
+  // A view, and an edit whose session has closed admission or been released, saves
+  // nothing here: its bytes are the reader's, and the exit's own barrier writes them.
+  if (!isEditMode || !writerAdmitted()) return;
   // A hide save still on the wire is answered after the page is gone too.
   const latest = unsentCaptureId ?? wireCaptureId;
   const pin = checkpoints.flushing && latest !== null ? capturePins.get(latest) : null;
@@ -1121,6 +1397,14 @@ export function storeOf(name) {
   return entries.get(name)?.store || null;
 }
 
+// A caller that opened a store itself is done with it: the next entry reads the tag the
+// reader now states. Only the store that caller opened is closed; one the app opened
+// first, or a staged store, stays.
+export function closeStore(name, store) {
+  const entry = entries.get(name);
+  if (entry && entry.store === store && !entry.staged) entries.delete(name);
+}
+
 export function openStores() {
   return [...entries.values()].map((entry) => entry.store);
 }

package/src/plugins/menu/claygoo.svg.js

@@ -0,0 +1 @@
+export default '<svg xmlns="http://www.w3.org/2000/svg" viewBox="-45.87 -57.96 100.26 60.98" fill="currentColor" aria-hidden="true" focusable="false"><path fill-rule="evenodd" d="M44.35 -4.56Q40.03 -0.52 34.69 -0.39Q29.34 -0.25 24.81 -0.14Q20.27 -0.02 15.6 0Q10.93 0.02 6.41 0Q1.89 -0.02 -2.79 -0.02Q-7.48 -0.02 -12.11 -0.14Q-16.73 -0.25 -21.64 -0.27Q-26.55 -0.3 -31.72 -2.25Q-36.88 -4.2 -39.87 -9.12Q-42.87 -14.03 -42.8 -19.61Q-42.74 -25.18 -40.43 -29.94Q-38.12 -34.69 -34.82 -38.78Q-31.52 -42.87 -27.25 -45.6Q-22.98 -48.33 -18.35 -50.59Q-13.73 -52.85 -8.7 -53.88Q-3.68 -54.91 1.32 -54.93Q6.32 -54.96 11.44 -54.56Q16.55 -54.16 21.35 -52.2Q26.16 -50.24 30.69 -48.01Q35.22 -45.78 38.99 -42.18Q42.76 -38.59 45.67 -34.37Q48.59 -30.15 49.99 -24.87Q51.39 -19.59 50.04 -14.09Q48.68 -8.6 44.35 -4.56ZM0.66 -30.49C0.5 -28.73 -0.88 -27.42 -2.42 -27.57C-3.96 -27.71 -5.08 -29.25 -4.91 -31.01C-4.75 -32.77 -3.36 -34.08 -1.83 -33.94C-0.29 -33.79 0.83 -32.25 0.66 -30.49ZM13.61 -29.28C13.44 -27.52 12.06 -26.21 10.52 -26.35C8.98 -26.5 7.87 -28.04 8.03 -29.8C8.2 -31.56 9.58 -32.87 11.12 -32.73C12.66 -32.58 13.77 -31.04 13.61 -29.28ZM-1.23 -17.71Q-0.62 -17.35 -0.03 -17.08Q0.56 -16.81 1.15 -16.54Q1.73 -16.28 2.4 -16Q3.07 -15.72 3.87 -15.6Q4.66 -15.48 5.4 -15.55Q6.13 -15.62 6.77 -15.79Q7.41 -15.96 7.97 -16.23Q8.53 -16.5 9 -16.91Q9.46 -17.32 9.73 -17.9Q9.99 -18.47 10.08 -19.12Q10.17 -19.77 10.08 -20.42Q9.99 -21.06 9.45 -21.32Q8.91 -21.58 8.27 -21.38Q7.63 -21.17 6.99 -20.91Q6.36 -20.65 5.7 -20.61Q5.04 -20.56 4.33 -20.73Q3.62 -20.9 2.92 -21.14Q2.23 -21.39 1.54 -21.68Q0.85 -21.97 0.16 -22.27Q-0.52 -22.56 -1.22 -22.79Q-1.92 -23.03 -2.49 -22.61Q-3.05 -22.19 -3.23 -21.5Q-3.4 -20.81 -3.2 -20.09Q-3.01 -19.38 -3.02 -19.15Q-3.02 -18.93 -2.42 -18.5Q-1.83 -18.06 -1.23 -17.71Z"/></svg>';