@gmickel/gno 1.43.0 → 1.44.0

package/browser-extension/artifacts/gno-browser-clipper-v1.44.0.zip.sha256

@@ -0,0 +1 @@
+31a5cf0632f64360093ef6184708a77244d0e65e6d344d3ba6e11902fcab12b1  gno-browser-clipper-v1.44.0.zip

package/browser-extension/dist/manifest.json

@@ -21,5 +21,5 @@
   "content_security_policy": {
     "extension_pages": "script-src 'self'; object-src 'none'; connect-src http://127.0.0.1:*"
   },
-  "version": "1.43.0"
+  "version": "1.44.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "1.43.0",
+  "version": "1.44.0",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "embeddings",

package/spec/cli.md

@@ -1025,24 +1025,51 @@ gno index [collection] [--no-embed] [--models-pull] [--git-pull] [--json] [--yes
 
 **Behavior:**
 
-- Runs `update` then `embed` by default
-- With `--no-embed`, runs `update` only
+- Runs two separable stages: `lexical` (`update`) then `embed`
+- With `--no-embed`, runs the `lexical` stage only (embed stage `skipped`)
 - Waits by default for the shared write lease; `--no-wait` fails immediately with exit 4
 
-**JSON output:** Emits `{ syncResult, embedSkipped, embedResult? }`.
+**Staged, resumable contract:** each stage persists its own progress inside
+the index database (documents and chunks for `lexical`; vectors per batch for
+`embed`) plus a per-stage lifecycle marker (`schema_meta.index_stage_state`).
+A stage that fails never invalidates a completed earlier stage: the lexical
+index stays searchable when embedding fails or the process dies. A process
+killed mid-stage (SIGKILL, native crash, power loss) emits nothing; the next
+`gno index` or `gno embed` run reads the marker, reports the interrupted stage
+in its resume preamble (stderr in human mode, `resumedFrom` in JSON), and
+continues from persisted progress - unchanged files are skipped and already
+stored chunks are never re-embedded. A `gno index --no-embed` run that
+surfaces an interrupted embed stage settles that marker (the embed progress
+itself stays on disk), so later runs do not repeat the preamble.
+
+**JSON output:** conforms to
+[`index-receipt@1.0`](./output-schemas/index-receipt.schema.json):
+`{ success, error?, stages: { lexical, embed }, resumedFrom, syncResult?, embedSkipped, embedResult? }`.
+Each stage reports `state` (`completed` | `failed` | `skipped` |
+`interrupted`) with counts (`filesProcessed`/`filesAdded`/`filesUpdated`/
+`filesErrored`/`filesSkipped`/`durationMs` for lexical;
+`embedded`/`errors`/`contentionErrors`/`durationMs` for embed), a `reason`
+when skipped, and an `error` when failed. The embed stage is `completed` only
+when every attempted chunk was stored: any `errors > 0` or a vector-sync error
+makes it `failed`. `resumedFrom` is `null` on a clean start or
+`{ stage, state: "interrupted", startedAt, pid, collection? }`.
 `syncResult.collections[].files[].recordImport`, when present, conforms to
 [`record-import@1.0`](./output-schemas/record-import.schema.json) with the same
 deterministic ordering, bounds, truncation disclosure, and partial-snapshot
 warnings as `gno update --json`. Human progress and diagnostics remain on
-stderr. On lease timeout, stdout is one object `{ success: false, error, contention }`
-and the process exits 4.
+stderr. A failed stage still emits the partial receipt on stdout (with
+`success: false` and `error`) before the non-zero exit. On lease timeout,
+stdout is one object `{ success: false, error, contention }` and the process
+exits 4.
 
 **Exit Codes:**
 
-- 0: Success
+- 0: Every attempted stage completed
 - 1: Invalid collection name or invalid `--lock-wait`
-- 2: DB or model failure
-- 4: Write lease busy (contention, not corruption)
+- 2: DB or model failure, or any stage `failed` (including chunk-level embed
+  failures; the partial receipt is still emitted)
+- 4: Write lease busy (contention, not corruption), or chunks deferred by
+  index contention after an otherwise completed embed stage
 
 **Examples:**
 
@@ -2372,11 +2399,21 @@ gno doctor [--json|--md]
           }
         ]
       }
+    },
+    {
+      "name": "findings-pass",
+      "status": "ok",
+      "message": "disabled (opt-in via findings.enabled)"
     }
   ]
 }
 ```
 
+The `findings-pass` check reports the daemon's scheduled findings pass from
+its persisted run state: `ok` when disabled or the last run succeeded, `warn`
+on `skipped_lease` / `overdue` / no recorded run, `error` on `failed` or a
+misconfigured `findings` block (see [Daemon Mode](../docs/DAEMON.md#scheduled-findings-pass)).
+
 The `embedding-fingerprint` check is additive doctor-only diagnostics. It uses
 the active embed model and stored vector dimensions to report the current
 freshness fingerprint, pending/stale chunks, legacy empty-fingerprint vectors,
@@ -3595,6 +3632,7 @@ List retained, metadata-only document lifecycle changes.
 
 ```bash
 gno changes [--since <ISO-8601|cursor>] [--collection <name>] [--limit <n>] [--json]
+gno changes --follow --jsonl [--cursor <cursor>] [--collection <name>]
 ```
 
 - `--since` accepts an ISO-8601 time or an opaque cursor returned by an earlier
@@ -3605,6 +3643,42 @@ gno changes [--since <ISO-8601|cursor>] [--collection <name>] [--limit <n>] [--j
   cursor-expiry, and retention-truncation disclosure.
 - The journal never returns source bodies.
 
+**Follow mode (`--follow --jsonl`)** streams journal events as they land and is
+the durable automation input for consumers that resume across restarts.
+
+- `--follow` and `--jsonl` are one mode and must be given together; `--cursor`
+  requires both. The mode excludes `--since`, `--limit`, and `--json` (exit 1).
+  `--collection` filters the stream.
+- Wire contract: one JSON object per stdout line, validated by
+  `changes-follow-event.schema.json`. An event line is
+  `{"event": <change>, "postCursor": "<cursor>"}` where `event` is one
+  `changes.schema.json` change and `postCursor` is the journal cursor after
+  that event was applied. Lines are emitted in journal order.
+- Checkpoint rule: a consumer persists `postCursor` after it has durably
+  handled the line and restarts with `--cursor <postCursor>`; nothing at or
+  before that cursor is replayed. Delivery is at-least-once: a line the
+  consumer received but did not checkpoint is redelivered on resume, so
+  handlers must be idempotent by `event.id` (each event id is unique and
+  equals its own `postCursor`).
+- Start position: without `--cursor` the stream starts at the journal's
+  current `latestCursor` (tail semantics, no backfill). `--cursor` must be an
+  opaque cursor from an earlier response (exit 1 when malformed or ahead of
+  the journal).
+- Quiet periods emit nothing. There is no keepalive line in v1; consumers
+  detect liveness from the process, not the stream.
+- Cursor expiry: when the resume cursor falls below the retention floor the
+  stream writes exactly one terminal line,
+  `{"error": "cursor_expired", "earliestCursor": "<cursor>", "latestCursor": "<cursor>"}`,
+  then exits 2 with nothing on stderr. `earliestCursor` is the journal's
+  documented resume floor (`gno changes --json` reports the same value);
+  `latestCursor` is the current tail. The consumer chooses whether to backfill
+  from `earliestCursor` or resume from `latestCursor` and accept the gap;
+  resuming from `latestCursor` skips every retained event.
+- Signals: SIGINT or SIGTERM ends the stream after the line in progress and
+  exits 0. No partial line is ever written.
+- The reader never takes the write lease; `gno index`, `gno update`, capture,
+  and the daemon are never blocked by a follower.
+
 ### gno diff
 
 Show the latest retained structural delta for one document, or select an exact
@@ -3851,6 +3925,13 @@ is blocked.
   watcher behavior.
 - Runs an initial sync by default
 - Triggers embedding after initial sync completes
+- With `findings.enabled`, runs the scheduled findings pass on its cadence:
+  a read-only audit of every collection except the findings one, written as
+  deterministic Markdown records into `findings.collection`. The audit runs
+  without the write lease; only the record write takes it (no wait; a busy
+  lease is recorded as `skipped_lease`). Every attempt persists to
+  `{data}/index-<name>.findings-run.json`, surfaced by `--status` (`findings`)
+  and the `findings-pass` doctor check. See [Daemon Mode](../docs/DAEMON.md#scheduled-findings-pass)
 - Runs in the foreground until `SIGINT` / `SIGTERM`
 - Starts a headless `/mcp` Streamable HTTP listener; it does not serve the Web UI
 - Exposes the same safe REST lifecycle snapshot at `/api/resident/status`;

package/spec/mcp.md

@@ -1537,6 +1537,17 @@ Create a new document in a collection (write-enabled).
 - For non-Markdown files, tags are stored as user-source in the database
 - Receipts distinguish write result from sync and embedding state; capture does
   not imply embedding unless `embed.status` is `completed`
+- Success is retrievability: the write and its lexical sync complete under the
+  shared write lease before the tool returns, so a successful result always
+  carries `sync.status: "completed"` and the note is an immediate `gno_search`
+  hit. A written file whose sync fails is a tool error `CAPTURE_SYNC_FAILED`
+  (message names the written path; run `gno update` to retry), never a success
+  with `sync.status: "failed"`
+- `open_existing` on a file that is on disk but not indexed yet syncs it before
+  returning `collisionPolicyResult: "opened_existing"`
+- The lease wait follows the v1.38 contention contract: the tool waits up to
+  120s for a concurrent CLI/MCP/REST writer, then returns `LOCKED` without
+  writing
 - Writes run under the MCP write lock and are only registered when the server
   starts with `--enable-write` or `GNO_MCP_ENABLE_WRITE=1`
 
@@ -2742,6 +2753,7 @@ Resource errors use standard MCP error responses.
 - `PATH_NOT_FOUND` — Path does not exist
 - `JOB_CONFLICT` — Another job is already running
 - `LOCKED` — Another MCP process holds the write lock
+- `CAPTURE_SYNC_FAILED` — `gno_capture` wrote the file but lexical sync failed
 - `WRITE_DISABLED` — Write tool dispatched while writes are disabled
 - `MEMORY_*` — Memory contract errors from `gno_recall` / `gno_remember`;
   the stable code set is `MemoryErrorCode` in `src/core/memory.ts` and each

package/spec/output-schemas/changes-follow-event.schema.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "gno://schemas/changes-follow-event@1.0",
+  "title": "GNO Knowledge Changes Follow Line",
+  "description": "One stdout line of `gno changes --follow --jsonl`: either a journal event with the cursor after it was applied, or the single terminal cursor-expiry record.",
+  "oneOf": [
+    { "$ref": "#/definitions/eventLine" },
+    { "$ref": "#/definitions/expiredLine" }
+  ],
+  "definitions": {
+    "eventLine": {
+      "type": "object",
+      "required": ["event", "postCursor"],
+      "properties": {
+        "event": { "$ref": "gno://schemas/changes@1.0#/definitions/change" },
+        "postCursor": { "type": "string", "minLength": 1, "maxLength": 512 }
+      },
+      "additionalProperties": false
+    },
+    "expiredLine": {
+      "type": "object",
+      "required": ["error", "earliestCursor", "latestCursor"],
+      "properties": {
+        "error": { "type": "string", "const": "cursor_expired" },
+        "earliestCursor": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 512
+        },
+        "latestCursor": { "type": "string", "minLength": 1, "maxLength": 512 }
+      },
+      "additionalProperties": false
+    }
+  }
+}

package/spec/output-schemas/index-receipt.schema.json

@@ -0,0 +1,135 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "gno://schemas/index-receipt@1.0",
+  "title": "GNO Index Receipt",
+  "description": "Per-stage receipt emitted by `gno index --json`. The lexical (sync) and embed stages are separable and resumable; the run succeeds only when every attempted stage completed. A run interrupted by a killed process emits nothing - the next run reports the interrupted stage under `resumedFrom`.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["success", "stages", "resumedFrom", "embedSkipped"],
+  "properties": {
+    "success": {
+      "type": "boolean",
+      "description": "True only when every attempted stage completed."
+    },
+    "error": {
+      "type": "string",
+      "description": "Present when success is false: the failed stage's error."
+    },
+    "stages": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["lexical", "embed"],
+      "properties": {
+        "lexical": { "$ref": "#/definitions/lexicalStage" },
+        "embed": { "$ref": "#/definitions/embedStage" }
+      }
+    },
+    "resumedFrom": {
+      "oneOf": [
+        { "$ref": "#/definitions/interruptedStage" },
+        { "type": "null" }
+      ],
+      "description": "Stage a previous run left running (process died mid-stage); null when this run started clean."
+    },
+    "syncResult": {
+      "type": "object",
+      "description": "Complete deterministic sync result (same shape as `gno update --json`); absent when the lexical stage failed before producing one."
+    },
+    "embedSkipped": {
+      "type": "boolean",
+      "description": "True when `--no-embed` was passed."
+    },
+    "embedResult": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["embedded", "errors", "contentionErrors", "duration"],
+      "description": "Embedding outcome when the embed stage ran to a result (present for completed and for partially failed passes; absent when the stage failed before embedding).",
+      "properties": {
+        "embedded": { "type": "integer", "minimum": 0 },
+        "errors": { "type": "integer", "minimum": 0 },
+        "contentionErrors": { "type": "integer", "minimum": 0 },
+        "duration": {
+          "type": "number",
+          "minimum": 0,
+          "description": "Seconds."
+        }
+      }
+    }
+  },
+  "definitions": {
+    "stageState": {
+      "type": "string",
+      "enum": ["completed", "failed", "skipped", "interrupted"]
+    },
+    "lexicalStage": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "state",
+        "filesProcessed",
+        "filesAdded",
+        "filesUpdated",
+        "filesErrored",
+        "filesSkipped",
+        "durationMs"
+      ],
+      "properties": {
+        "state": { "$ref": "#/definitions/stageState" },
+        "filesProcessed": { "type": "integer", "minimum": 0 },
+        "filesAdded": { "type": "integer", "minimum": 0 },
+        "filesUpdated": { "type": "integer", "minimum": 0 },
+        "filesErrored": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Per-file errors are counted, not fatal; the stage still completes."
+        },
+        "filesSkipped": { "type": "integer", "minimum": 0 },
+        "durationMs": { "type": "integer", "minimum": 0 },
+        "error": { "type": "string" }
+      }
+    },
+    "embedStage": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "state",
+        "embedded",
+        "errors",
+        "contentionErrors",
+        "durationMs"
+      ],
+      "properties": {
+        "state": { "$ref": "#/definitions/stageState" },
+        "embedded": { "type": "integer", "minimum": 0 },
+        "errors": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Chunks that failed to embed after same-run retries; any non-zero value makes the stage `failed`."
+        },
+        "contentionErrors": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Chunks deferred by SQLITE_BUSY/LOCKED - not embedding failures."
+        },
+        "durationMs": { "type": "integer", "minimum": 0 },
+        "reason": {
+          "type": "string",
+          "description": "Why the stage was skipped (`--no-embed`, `lexical stage failed`)."
+        },
+        "error": { "type": "string" }
+      }
+    },
+    "interruptedStage": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["stage", "state", "startedAt", "pid"],
+      "properties": {
+        "stage": { "type": "string", "enum": ["lexical", "embed"] },
+        "state": { "const": "interrupted" },
+        "startedAt": { "type": "string", "format": "date-time" },
+        "pid": { "type": "integer", "minimum": 1 },
+        "collection": { "type": "string" }
+      }
+    }
+  }
+}

package/spec/output-schemas/process-status.schema.json

@@ -71,6 +71,82 @@
       "type": ["integer", "null"],
       "minimum": 0,
       "description": "Current size of the log-file in bytes, or null when the file does not exist"
+    },
+    "findings": {
+      "description": "Daemon only: persisted last-run state of the scheduled findings pass, or null when findings.enabled is false / never configured. Read from the data-dir state file, so it survives daemon restarts.",
+      "anyOf": [
+        { "type": "null" },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "schemaVersion",
+            "state",
+            "collection",
+            "cadence",
+            "lastOutcome",
+            "lastRunAt",
+            "lastSuccessAt",
+            "nextDueAt",
+            "durationMs",
+            "counts",
+            "error"
+          ],
+          "properties": {
+            "schemaVersion": { "const": "1.0" },
+            "state": {
+              "type": "string",
+              "enum": [
+                "pending",
+                "success",
+                "failed",
+                "skipped_lease",
+                "overdue"
+              ],
+              "description": "lastOutcome, or overdue once nextDueAt has slipped by a full cadence"
+            },
+            "collection": { "type": "string" },
+            "cadence": { "type": "string" },
+            "lastOutcome": {
+              "type": "string",
+              "enum": ["pending", "success", "failed", "skipped_lease"]
+            },
+            "lastRunAt": { "type": ["string", "null"], "format": "date-time" },
+            "lastSuccessAt": {
+              "type": ["string", "null"],
+              "format": "date-time"
+            },
+            "nextDueAt": { "type": "string", "format": "date-time" },
+            "durationMs": { "type": ["integer", "null"], "minimum": 0 },
+            "counts": {
+              "anyOf": [
+                { "type": "null" },
+                {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "required": [
+                    "findings",
+                    "written",
+                    "reopened",
+                    "resolved",
+                    "deleted",
+                    "open"
+                  ],
+                  "properties": {
+                    "findings": { "type": "integer", "minimum": 0 },
+                    "written": { "type": "integer", "minimum": 0 },
+                    "reopened": { "type": "integer", "minimum": 0 },
+                    "resolved": { "type": "integer", "minimum": 0 },
+                    "deleted": { "type": "integer", "minimum": 0 },
+                    "open": { "type": "integer", "minimum": 0 }
+                  }
+                }
+              ]
+            },
+            "error": { "type": ["string", "null"] }
+          }
+        }
+      ]
     }
   },
   "allOf": [

package/src/cli/commands/changes-follow.ts

@@ -0,0 +1,167 @@
+/**
+ * Streaming read path over the document change journal for
+ * `gno changes --follow --jsonl`.
+ *
+ * Wire contract (spec/cli.md "gno changes"): one JSON object per line. Event
+ * lines are `{event, postCursor}` where `postCursor` is the journal cursor
+ * after that event was applied; a consumer that persists `postCursor` and
+ * resumes with `--cursor <postCursor>` sees nothing before it again. Quiet
+ * periods emit nothing. When the resume cursor falls below the retention
+ * floor, exactly one terminal `{error: "cursor_expired", earliestCursor,
+ * latestCursor}` line is written and the loop returns `expired`.
+ */
+
+import type { KnowledgeChange } from "../../core/knowledge-delta";
+import type { StorePort } from "../../store/types";
+
+import {
+  decodeDocumentChangeCursor,
+  encodeDocumentChangeCursor,
+} from "../../core/change-journal";
+import { projectKnowledgeChange } from "../../core/knowledge-delta";
+
+/** Poll cadence between empty journal reads; pages drain back-to-back. */
+export const FOLLOW_POLL_INTERVAL_MS = 250;
+const FOLLOW_PAGE_SIZE = 500;
+
+export interface ChangesFollowEvent {
+  event: KnowledgeChange;
+  postCursor: string;
+}
+
+export interface ChangesFollowExpired {
+  error: "cursor_expired";
+  earliestCursor: string;
+  latestCursor: string;
+}
+
+export type ChangesFollowLine = ChangesFollowEvent | ChangesFollowExpired;
+
+export interface FollowChangesOptions {
+  /** Resume cursor; omitted means start at the journal's latest cursor. */
+  cursor?: string;
+  collection?: string;
+  signal: AbortSignal;
+  pollIntervalMs?: number;
+}
+
+export type FollowChangesResult =
+  | { status: "stopped"; cursor: string }
+  | { status: "expired"; earliestCursor: string; latestCursor: string }
+  | { status: "error"; error: string; isValidation: boolean };
+
+export const validateFollowCursor = (cursor: string): string | null => {
+  try {
+    decodeDocumentChangeCursor(cursor);
+    return null;
+  } catch {
+    return "cursor must be an opaque change cursor from an earlier response";
+  }
+};
+
+const sleep = (ms: number, signal: AbortSignal): Promise<void> =>
+  new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    const onAbort = (): void => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+
+/** Sequence behind an opaque cursor, or `null` when it does not decode. */
+const cursorSequence = (cursor: string): number | null => {
+  try {
+    return decodeDocumentChangeCursor(cursor);
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Later of two opaque cursors. Each side is decoded on its own: a malformed
+ * side yields the other, and when both are malformed `left` wins.
+ */
+const maxCursor = (left: string, right: string): string => {
+  const leftSequence = cursorSequence(left);
+  const rightSequence = cursorSequence(right);
+  if (leftSequence === null) return rightSequence === null ? left : right;
+  if (rightSequence === null) return left;
+  return encodeDocumentChangeCursor(Math.max(leftSequence, rightSequence));
+};
+
+/**
+ * Stream journal events to `emit` until the signal aborts, the cursor
+ * expires, or the store fails. Each event line is emitted after the cursor
+ * it carries is final, so the caller can checkpoint per line.
+ */
+export async function followChanges(
+  store: StorePort,
+  options: FollowChangesOptions,
+  emit: (line: ChangesFollowLine) => void
+): Promise<FollowChangesResult> {
+  const { signal } = options;
+  const pollIntervalMs = options.pollIntervalMs ?? FOLLOW_POLL_INTERVAL_MS;
+  let cursor = options.cursor;
+
+  if (cursor === undefined) {
+    const head = await store.listDocumentChanges({ limit: 1 });
+    if (!head.ok) {
+      return {
+        status: "error",
+        error: head.error.message,
+        isValidation: false,
+      };
+    }
+    cursor = head.value.latestCursor;
+  }
+
+  while (!signal.aborted) {
+    const page = await store.listDocumentChanges({
+      cursor,
+      collection: options.collection,
+      limit: FOLLOW_PAGE_SIZE,
+    });
+    if (!page.ok) {
+      return {
+        status: "error",
+        error: page.error.message,
+        isValidation: page.error.code === "INVALID_INPUT",
+      };
+    }
+    if (page.value.cursorExpired) {
+      const { earliestCursor, latestCursor } = page.value;
+      emit({ error: "cursor_expired", earliestCursor, latestCursor });
+      return { status: "expired", earliestCursor, latestCursor };
+    }
+    let drained = true;
+    for (const row of page.value.changes) {
+      if (signal.aborted) {
+        drained = false;
+        break;
+      }
+      const event = projectKnowledgeChange(row);
+      // The change id encodes the sequence that produced it, which is exactly
+      // the journal position after applying the event.
+      cursor = event.id;
+      emit({ event, postCursor: cursor });
+    }
+    if (page.value.truncated) continue;
+    // An untruncated page was scanned to the journal head even when a
+    // collection filter emitted nothing from it: advance to that high-water
+    // mark so the next poll does not rescan the same tail. Emitted events keep
+    // their own postCursor; this only moves the internal resume point.
+    if (drained) {
+      cursor = maxCursor(cursor, page.value.latestCursor);
+    }
+    await sleep(pollIntervalMs, signal);
+  }
+  return { status: "stopped", cursor };
+}