@synap-core/cli 1.11.0 → 1.13.0

package/templates/automations/bookmark-enrichment.automation.json

@@ -4,41 +4,318 @@
   "status": "active",
   "triggerConfig": {
     "eventPattern": "entity.create.completed",
-    "filters": { "profileSlug": "bookmark" }
+    "filters": {
+      "profileSlug": "bookmark"
+    }
   },
   "flowDefinition": {
     "nodes": [
       {
         "id": "trigger",
         "type": "trigger",
-        "position": { "x": 0, "y": 0 },
+        "position": {
+          "x": 0,
+          "y": 0
+        },
         "data": {
           "triggerType": "event",
           "label": "Bookmark created",
           "config": {
             "eventPattern": "entity.create.completed",
-            "filters": { "profileSlug": "bookmark" }
+            "filters": {
+              "profileSlug": "bookmark"
+            }
           }
         }
       },
       {
-        "id": "enrich",
-        "type": "skill",
-        "position": { "x": 0, "y": 120 },
+        "id": "read",
+        "type": "entity_read",
+        "position": {
+          "x": 0,
+          "y": 120
+        },
         "data": {
-          "label": "Bookmark Enrichment",
-          "skillName": "bookmark-enrichment",
-          "skillTitle": "Bookmark Enrichment",
+          "label": "Read the bookmark",
+          "entityId": "{{trigger.payload.subjectId}}"
+        }
+      },
+      {
+        "id": "graph-context",
+        "type": "related_entities",
+        "position": {
+          "x": 0,
+          "y": 240
+        },
+        "data": {
+          "label": "What the graph already connects (deterministic)",
+          "entityId": "{{trigger.payload.subjectId}}",
+          "direction": "both",
+          "limit": 10
+        }
+      },
+      {
+        "id": "channel-talk",
+        "type": "messages_query",
+        "position": {
+          "x": 0,
+          "y": 360
+        },
+        "data": {
+          "label": "What was being discussed (deterministic)",
+          "channelId": "{{steps.read.output.entity.properties.sourceChannelId}}",
+          "limit": 10,
+          "errorHandling": {
+            "continueOnError": true
+          }
+        }
+      },
+      {
+        "id": "sharer-lookup",
+        "type": "query",
+        "position": {
+          "x": 0,
+          "y": 480
+        },
+        "data": {
+          "label": "Resolve the sharer to a person entity (deterministic)",
+          "profileSlug": "person",
+          "filter": "{\"title\": \"{{steps.read.output.entity.properties.sharedBy}}\"}",
+          "limit": 5
+        }
+      },
+      {
+        "id": "has-sharer-name",
+        "type": "condition",
+        "position": {
+          "x": 0,
+          "y": 600
+        },
+        "data": {
+          "label": "Bookmark carries a sharer name?",
+          "expression": "steps.read.output.entity.properties.sharedBy !== ''"
+        }
+      },
+      {
+        "id": "sharer-matches",
+        "type": "condition",
+        "position": {
+          "x": 0,
+          "y": 720
+        },
+        "data": {
+          "label": "Matched person's title equals the sharer name exactly?",
+          "expression": "steps.sharer-lookup.output.entities.0.title === steps.read.output.entity.properties.sharedBy"
+        }
+      },
+      {
+        "id": "link-sharer",
+        "type": "output",
+        "position": {
+          "x": 0,
+          "y": 840
+        },
+        "data": {
+          "label": "Link bookmark → the person who shared it",
+          "outputType": "relation_create",
+          "config": {
+            "fromEntityId": "{{trigger.payload.subjectId}}",
+            "toEntityId": "{{steps.sharer-lookup.output.entities.0.id}}",
+            "relationType": "created_by"
+          }
+        }
+      },
+      {
+        "id": "classify",
+        "type": "capability",
+        "position": {
+          "x": 0,
+          "y": 1200
+        },
+        "data": {
+          "label": "Describe + classify (AI) — title only if the captured one is unusable",
+          "verbId": "ai.generate",
           "inputMapping": {
-            "entityId": "{{trigger.payload.subjectId}}"
+            "system": "You name saved links for a personal knowledge base. Answer with a JSON object and nothing else: {\"title\": string, \"description\": string, \"category\": string}. `title` is a short human-readable name for the link (max 70 chars, no URL, no quotes). `description` is one factual sentence (max 200 chars). `category` is ONE lowercase word from: article, video, tool, repo, docs, social, media, other. You CANNOT open the link. Use ONLY the URL, the already-resolved graph context and the surrounding conversation you are given. `description` and `category` are ALWAYS used. `title` is used ONLY when the link has no usable name yet — when 'Current name' below already reads like a real title, it is kept and yours is discarded, so never optimise for replacing it. If the material does not tell you what the page is, set `title` to the empty string rather than guessing.",
+            "prompt": "URL: {{steps.read.output.entity.properties.url}}\nCurrent name: {{steps.read.output.entity.title}}\nShared by: {{steps.read.output.entity.properties.sharedBy}}\n\nAlready connected in the graph:\n{{steps.graph-context.output.entities}}\n\nSurrounding conversation in the source channel:\n{{steps.channel-talk.output.messages}}\n\nThe message it arrived in:\n{{steps.read.output.entity.preview}}",
+            "json": "true",
+            "maxTokens": "2000"
+          }
+        }
+      },
+      {
+        "id": "apply-enrich",
+        "type": "output",
+        "position": {
+          "x": -400,
+          "y": 1500
+        },
+        "data": {
+          "label": "Write description + category back (always)",
+          "outputType": "entity_update",
+          "config": {
+            "entityId": "{{trigger.payload.subjectId}}",
+            "properties": {
+              "description": "{{steps.classify.output.description}}",
+              "category": "{{steps.classify.output.category}}"
+            }
+          }
+        }
+      },
+      {
+        "id": "title-present",
+        "type": "condition",
+        "position": {
+          "x": 400,
+          "y": 1350
+        },
+        "data": {
+          "label": "Did the link arrive with a name?",
+          "expression": "steps.read.output.entity.title !== ''"
+        }
+      },
+      {
+        "id": "title-not-url",
+        "type": "condition",
+        "position": {
+          "x": 400,
+          "y": 1470
+        },
+        "data": {
+          "label": "…and is that name more than the raw URL?",
+          "expression": "steps.read.output.entity.title !== steps.read.output.entity.properties.url"
+        }
+      },
+      {
+        "id": "usable-title",
+        "type": "guard",
+        "position": {
+          "x": 0,
+          "y": 1320
+        },
+        "data": {
+          "label": "Only rename when the model produced a real title",
+          "checks": [
+            {
+              "path": "steps.classify.output.title",
+              "minLength": 3,
+              "message": "ai.generate returned no usable title — leaving the bookmark's captured name untouched."
+            }
+          ]
+        }
+      },
+      {
+        "id": "apply-title",
+        "type": "output",
+        "position": {
+          "x": 0,
+          "y": 1440
+        },
+        "data": {
+          "label": "Write the AI title back (only when the captured one was unusable)",
+          "outputType": "entity_update",
+          "config": {
+            "entityId": "{{trigger.payload.subjectId}}",
+            "title": "{{steps.classify.output.title}}",
+            "properties": {
+              "title": "{{steps.classify.output.title}}"
+            }
           }
         }
       }
     ],
-    "edges": [{ "id": "e1", "source": "trigger", "target": "enrich" }]
+    "edges": [
+      {
+        "id": "trigger->read",
+        "source": "trigger",
+        "target": "read"
+      },
+      {
+        "id": "read->graph-context",
+        "source": "read",
+        "target": "graph-context"
+      },
+      {
+        "id": "graph-context->channel-talk",
+        "source": "graph-context",
+        "target": "channel-talk"
+      },
+      {
+        "id": "channel-talk->sharer-lookup",
+        "source": "channel-talk",
+        "target": "sharer-lookup"
+      },
+      {
+        "id": "sharer-lookup->has-sharer-name",
+        "source": "sharer-lookup",
+        "target": "has-sharer-name"
+      },
+      {
+        "id": "has-sharer-name->sharer-matches",
+        "source": "has-sharer-name",
+        "target": "sharer-matches",
+        "sourceHandle": "yes"
+      },
+      {
+        "id": "sharer-matches->link-sharer",
+        "source": "sharer-matches",
+        "target": "link-sharer",
+        "sourceHandle": "yes"
+      },
+      {
+        "id": "link-sharer->classify",
+        "source": "link-sharer",
+        "target": "classify"
+      },
+      {
+        "id": "has-sharer-name->classify",
+        "source": "has-sharer-name",
+        "target": "classify",
+        "sourceHandle": "no"
+      },
+      {
+        "id": "sharer-matches->classify",
+        "source": "sharer-matches",
+        "target": "classify",
+        "sourceHandle": "no"
+      },
+      {
+        "id": "classify->apply-enrich",
+        "source": "classify",
+        "target": "apply-enrich"
+      },
+      {
+        "id": "classify->title-present",
+        "source": "classify",
+        "target": "title-present"
+      },
+      {
+        "id": "title-present->title-not-url",
+        "source": "title-present",
+        "target": "title-not-url",
+        "sourceHandle": "yes"
+      },
+      {
+        "id": "title-present->usable-title",
+        "source": "title-present",
+        "target": "usable-title",
+        "sourceHandle": "no"
+      },
+      {
+        "id": "title-not-url->usable-title",
+        "source": "title-not-url",
+        "target": "usable-title",
+        "sourceHandle": "no"
+      },
+      {
+        "id": "usable-title->apply-title",
+        "source": "usable-title",
+        "target": "apply-title"
+      }
+    ]
   },
   "metadata": {
     "source": "bridge-template",
-    "note": "The skill node carries `skillName`; the CLI seed command resolves it to the live `skillId` at install time (GET /skills by name)."
+    "note": "DETERMINISTIC-FIRST. Everything reachable without a network call runs BEFORE the AI: `related_entities` (what the graph already connects to this bookmark — the capture flow's `references` edge to the channel's bound entity lands here), `messages_query` on the captured `sourceChannelId` (what was being discussed), and a `query` on `person` resolving the captured `sharedBy` display name to a real person entity, linked with the EXISTING `created_by` relation def (no new def, no new node type). ai.generate is now the LAST RESORT: it runs only when the captured name is empty OR is the raw URL — the branch `title-present`→`title-not-url` — so a human-written message preview is never overwritten by a guess, and when the AI does run it is handed the deterministic context instead of a bare URL. Two condition merges (`title-present`, `classify`) rely on markDescendantsSkipped's live-parent rule (graph-topology.ts) — a merge node survives as long as ONE incoming edge is unpruned. `sharer-lookup` uses the STRING filter form on purpose: `parseQueryFilterConditions` template-resolves a STRING filter but pushes an OBJECT filter's values RAW, so the object form would have compared the literal `{{...}}` text and silently matched nothing. The `sharer-matches` exact-equality condition is the containment for that string form: if a name with a quote breaks JSON.parse the filter is dropped and the query widens, and this check refuses to link a non-identical title. `messages_query` carries `continueOnError` because it THROWS when the channel is not visible in the automation's workspace. NOT expressible today: host→company/tool matching. `transform` has no host/hostname pipe and the query filter compiles only exact equality ($eq/$gt/$gte/$lt/$lte/$ne — no substring/LIKE), so a host could never be matched against a `website` property holding a full URL. A page `fetch` is deliberately still absent."
   }
-}
+}

package/templates/automations/url-bookmark-capture.automation.json

@@ -22,18 +22,36 @@
         }
       },
       {
-        "id": "extract",
+        "id": "content",
         "type": "transform",
         "position": { "x": 0, "y": 120 },
         "data": {
-          "label": "Extract URLs",
-          "expression": "{{trigger.payload.data.content}} | url_extract"
+          "label": "Trim message text",
+          "expression": "{{trigger.payload.data.content}} | trim"
+        }
+      },
+      {
+        "id": "title-src",
+        "type": "transform",
+        "position": { "x": 0, "y": 240 },
+        "data": {
+          "label": "Human text (title source)",
+          "expression": "{{trigger.payload.data.messagePreview}} | trim"
+        }
+      },
+      {
+        "id": "extract",
+        "type": "transform",
+        "position": { "x": 0, "y": 360 },
+        "data": {
+          "label": "Extract URLs · drop bare-link noise",
+          "expression": "{{trigger.payload.data.content}} | url_extract | unique | filter:item !== steps.content.output.result | slice:5"
         }
       },
       {
         "id": "url-loop",
         "type": "loop",
-        "position": { "x": 0, "y": 240 },
+        "position": { "x": 0, "y": 480 },
         "data": {
           "label": "For each URL",
           "iteratorExpression": "steps.extract.output.result",
@@ -43,28 +61,72 @@
       {
         "id": "create-bookmark",
         "type": "output",
-        "position": { "x": 0, "y": 360 },
+        "position": { "x": 0, "y": 600 },
         "data": {
           "label": "Create bookmark",
           "outputType": "entity_create",
           "config": {
             "profileSlug": "bookmark",
-            "title": "{{loop.item}}",
+            "title": "{{steps.title-src.output.result}}",
             "dedupeBy": "url",
+            "body": "{{steps.content.output.result}}",
             "properties": {
               "url": "{{loop.item}}",
+              "sourceChannelId": "{{trigger.payload.data.channelId}}",
+              "sourceThreadId": "{{trigger.payload.data.threadId}}",
               "sourceMessageId": "{{trigger.payload.data.messageId}}",
-              "sourceChannelId": "{{trigger.payload.data.threadId}}"
+              "sourceProvider": "{{trigger.payload.data.provider}}",
+              "sharedBy": "{{trigger.payload.data.participantName}}"
             }
           }
         }
+      },
+      {
+        "id": "has-bookmark-id",
+        "type": "condition",
+        "position": { "x": 0, "y": 720 },
+        "data": {
+          "label": "Bookmark row exists?",
+          "expression": "steps.create-bookmark.output.entityId !== ''"
+        }
+      },
+      {
+        "id": "has-context-entity",
+        "type": "condition",
+        "position": { "x": 0, "y": 840 },
+        "data": {
+          "label": "Channel bound to an entity?",
+          "expression": "trigger.payload.data.entityId !== ''"
+        }
+      },
+      {
+        "id": "link-context",
+        "type": "output",
+        "position": { "x": 0, "y": 960 },
+        "data": {
+          "label": "Link bookmark → channel's entity",
+          "outputType": "relation_create",
+          "config": {
+            "fromEntityId": "{{steps.create-bookmark.output.entityId}}",
+            "toEntityId": "{{trigger.payload.data.entityId}}",
+            "relationType": "references"
+          }
+        }
       }
     ],
     "edges": [
-      { "id": "e1", "source": "trigger", "target": "extract" },
-      { "id": "e2", "source": "extract", "target": "url-loop" },
-      { "id": "e3", "source": "url-loop", "target": "create-bookmark" }
+      { "id": "e1", "source": "trigger", "target": "content" },
+      { "id": "e2", "source": "content", "target": "title-src" },
+      { "id": "e3", "source": "title-src", "target": "extract" },
+      { "id": "e4", "source": "extract", "target": "url-loop" },
+      { "id": "e5", "source": "url-loop", "target": "create-bookmark" },
+      { "id": "e6", "source": "create-bookmark", "target": "has-bookmark-id" },
+      { "id": "e7", "source": "has-bookmark-id", "target": "has-context-entity", "sourceHandle": "yes" },
+      { "id": "e8", "source": "has-context-entity", "target": "link-context", "sourceHandle": "yes" }
     ]
   },
-  "metadata": { "source": "bridge-template" }
+  "metadata": {
+    "source": "bridge-template",
+    "note": "Phase 1 is DETERMINISTIC — no AI. It keeps the context the trigger already hands it: data.channelId (the INTERNAL Synap channel UUID, not the Discord snowflake, which is kept separately as sourceThreadId), data.content (as the bookmark body) and data.entityId (the channel's bound entity, linked with a `references` relation). Title = the message's own 120-char preview; when the message is nothing but a link the item is dropped by the noise filter rather than named, so the title is never invented. Noise filter: `filter:item !== steps.content.output.result` keeps only links that arrived WITH human text — a Tenor/giphy GIF drop or a bare Google Photos paste is exactly a message whose whole trimmed text IS the URL. A host denylist is NOT expressible: the condition grammar (condition-eval.ts) has no substring/regex operator and `contains` is exact set intersection, so any 'tenor.com'-style match would silently never fire."
+  }
 }

package/templates/box/runner.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""The synap box runner: the only program the box template starts on boot.
+
+It holds no credential. It fetches its job from the provisioner by the
+provisioner's address on the isolated bridge, installs the declared packages
+(setup phase: the egress proxy lets only the package registries through),
+tells the provisioner it is done installing (run phase: only the declared
+hosts), runs the script as the unprivileged user `box` with /in and /out,
+streams the log back, uploads /out and reports the exit code.
+
+The provisioner, not this program, enforces the wall clock: it destroys the box.
+Python stdlib only (Debian 12's python3), so the template needs nothing else to
+run it. Contract with the provisioner: synap-cli src/lib/box/job-server.ts.
+"""
+
+import json
+import os
+import pwd
+import subprocess
+import sys
+import threading
+import time
+import urllib.parse
+import urllib.request
+
+BASE = os.environ.get("SYNAP_BOX_PROVISIONER", "http://10.20.0.1:8790")
+PROXY = os.environ.get("SYNAP_BOX_PROXY", "http://10.20.0.1:3128")
+WORK, IN, OUT = "/work", "/in", "/out"
+USER = "box"
+MAX_OUT_FILES = 20
+
+# The job server is on the bridge: never through the proxy.
+_direct = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+
+
+def call(method, path, body=None, ctype="application/json", timeout=60):
+    data = body if isinstance(body, (bytes, type(None))) else json.dumps(body).encode()
+    req = urllib.request.Request(BASE + path, data=data, method=method)
+    if data is not None:
+        req.add_header("Content-Type", ctype)
+    with _direct.open(req, timeout=timeout) as res:
+        raw = res.read()
+        return json.loads(raw) if raw and res.headers.get("content-type", "").startswith("application/json") else None
+
+
+def fetch_job():
+    # The box may boot before the provisioner registers its address: retry.
+    deadline = time.time() + 180
+    while True:
+        try:
+            return call("GET", "/job")
+        except Exception as err:  # noqa: BLE001
+            if time.time() > deadline:
+                raise SystemExit(f"no job from {BASE}: {err}")
+            time.sleep(2)
+
+
+class LogPump:
+    """Batches output and POSTs it to /log about twice a second."""
+
+    def __init__(self):
+        self.buf = bytearray()
+        self.lock = threading.Lock()
+        self.stop = threading.Event()
+        self.thread = threading.Thread(target=self._loop, daemon=True)
+        self.thread.start()
+
+    def write(self, data):
+        with self.lock:
+            self.buf += data
+
+    def _flush(self):
+        with self.lock:
+            chunk, self.buf = bytes(self.buf), bytearray()
+        if chunk:
+            try:
+                call("POST", "/log", chunk, "application/octet-stream")
+            except Exception:  # noqa: BLE001 - a lost log chunk must not kill the run
+                pass
+
+    def _loop(self):
+        while not self.stop.wait(0.5):
+            self._flush()
+
+    def close(self):
+        self.stop.set()
+        self.thread.join()
+        self._flush()
+
+
+def demote(user):
+    pw = pwd.getpwnam(user)
+
+    def run_as():
+        os.setgroups([])
+        os.setgid(pw.pw_gid)
+        os.setuid(pw.pw_uid)
+
+    return run_as, pw
+
+
+def run(cmd, env, pump):
+    """Run cmd as the box user; its stdout+stderr go to the log. Returns the exit code."""
+    pre, pw = demote(USER)
+    pump.write(("$ " + " ".join(cmd) + "\n").encode())
+    proc = subprocess.Popen(
+        cmd, cwd=WORK, env={**env, "HOME": pw.pw_dir, "USER": USER},
+        stdout=subprocess.PIPE, stderr=subprocess.STDOUT, preexec_fn=pre,
+    )
+    for chunk in iter(lambda: proc.stdout.read1(65536), b""):
+        pump.write(chunk)
+    return proc.wait()
+
+
+def installed(job, env):
+    try:
+        if job["language"] == "python":
+            out = subprocess.run(
+                ["uv", "pip", "list", "--python", f"{WORK}/.venv/bin/python", "--format", "json"],
+                cwd=WORK, env=env, capture_output=True, timeout=60,
+            ).stdout
+            return [{"name": p["name"], "version": p["version"], "manager": "pip"} for p in json.loads(out or b"[]")]
+        out = subprocess.run(
+            ["pnpm", "list", "--json", "--depth", "0"], cwd=WORK, env=env, capture_output=True, timeout=60,
+        ).stdout
+        deps = (json.loads(out or b"[{}]") or [{}])[0].get("dependencies", {}) or {}
+        return [{"name": n, "version": d.get("version", ""), "manager": "npm"} for n, d in deps.items()]
+    except Exception:  # noqa: BLE001 - the list is evidence, not the verdict
+        return []
+
+
+def upload_out(pump):
+    sent = 0
+    for root, _dirs, files in os.walk(OUT):
+        for name in sorted(files):
+            full = os.path.join(root, name)
+            if os.path.islink(full) or not os.path.isfile(full):
+                continue
+            rel = os.path.relpath(full, OUT)
+            if sent >= MAX_OUT_FILES:
+                pump.write(f"\n[synap box] /out/{rel} skipped: at most {MAX_OUT_FILES} files\n".encode())
+                continue
+            try:
+                with open(full, "rb") as fh:
+                    call("PUT", "/out/" + urllib.parse.quote(rel), fh.read(), "application/octet-stream", timeout=600)
+                sent += 1
+            except Exception as err:  # noqa: BLE001
+                pump.write(f"\n[synap box] /out/{rel} not uploaded: {err}\n".encode())
+
+
+def main():
+    job = fetch_job()
+    pump = LogPump()
+    for d in (WORK, IN, OUT):
+        os.makedirs(d, exist_ok=True)
+    pw = pwd.getpwnam(USER)
+    for d in (WORK, OUT):
+        os.chown(d, pw.pw_uid, pw.pw_gid)
+
+    entry = os.path.normpath(job["entrypoint"])
+    if entry.startswith("..") or os.path.isabs(entry):
+        raise SystemExit(f"bad entrypoint {job['entrypoint']!r}")
+    os.makedirs(os.path.dirname(os.path.join(WORK, entry)), exist_ok=True)
+    with open(os.path.join(WORK, entry), "w") as fh:
+        fh.write(job["code"])
+    os.chown(os.path.join(WORK, entry), pw.pw_uid, pw.pw_gid)
+    with open(os.path.join(IN, "parameters.json"), "w") as fh:
+        json.dump(job.get("parameters"), fh)
+
+    env = {
+        "PATH": "/usr/local/bin:/usr/bin:/bin",
+        "LANG": "C.UTF-8",
+        "HTTP_PROXY": PROXY, "HTTPS_PROXY": PROXY, "http_proxy": PROXY, "https_proxy": PROXY,
+        "npm_config_proxy": PROXY, "npm_config_https_proxy": PROXY,
+        # Node's own fetch ignores HTTP(S)_PROXY unless told (Node >= 22.21 / 24).
+        "NODE_USE_ENV_PROXY": "1",
+        "UV_CACHE_DIR": f"{WORK}/.cache/uv", "npm_config_cache": f"{WORK}/.cache/npm",
+        "SYNAP_PARAMETERS_FILE": f"{IN}/parameters.json", "SYNAP_OUT_DIR": OUT,
+    }
+    pkgs = job.get("packages") or []
+    if job["language"] == "python":
+        code = run(["uv", "venv", f"{WORK}/.venv"], env, pump)
+        if code == 0 and pkgs:
+            code = run(["uv", "pip", "install", "--python", f"{WORK}/.venv/bin/python",
+                        *[f"{p['name']}=={p['version']}" for p in pkgs]], env, pump)
+        cmd = [f"{WORK}/.venv/bin/python", entry]
+    else:
+        with open(os.path.join(WORK, "package.json"), "w") as fh:
+            json.dump({"private": True}, fh)
+        os.chown(os.path.join(WORK, "package.json"), pw.pw_uid, pw.pw_gid)
+        code = run(["pnpm", "add", *[f"{p['name']}@{p['version']}" for p in pkgs]], env, pump) if pkgs else 0
+        cmd = ["node", entry]
+
+    call("POST", "/phase", {"phase": "run"})
+    if code == 0:
+        code = run(cmd, env, pump)
+    else:
+        pump.write(f"\n[synap box] packages did not install (exit {code}); the script was not run\n".encode())
+
+    upload_out(pump)
+    pump.close()
+    call("POST", "/done", {"exitCode": code, "installedPackages": installed(job, env)})
+
+
+if __name__ == "__main__":
+    sys.exit(main())