@intentius/chant 0.124.13 → 0.124.15

package/dist/workspace/records-review.schema.json

@@ -0,0 +1,367 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://intentius.io/chant/schemas/workspace/records-review/v1/records-review.schema.json",
+  "title": "chant workspace records review output",
+  "description": "What `chant workspace records review <id> --kind <kind file> --verdict <verdict> --by <principal>` prints (#2670): the record's path and id and the review entry appended, or the reason it wrote nothing. Version 1 of the write contract for records. The command writes one file or none, or with --session the record and the session (#2693), and never commits. Readers ignore fields they do not know; a field is only ever added within a version. The error codes are a closed list, each in the one closed list of `reason-codes.ts`. Contract version 1 of this document is written by chant 0.86.0 and newer.",
+  "oneOf": [
+    {
+      "$ref": "#/$defs/result"
+    },
+    {
+      "$ref": "#/$defs/failure"
+    }
+  ],
+  "$defs": {
+    "result": {
+      "description": "The record was written, or would be with --dry-run. Exit code 0.",
+      "type": "object",
+      "required": [
+        "$schema",
+        "contract",
+        "kind",
+        "path",
+        "id",
+        "review",
+        "dryRun",
+        "warnings"
+      ],
+      "properties": {
+        "$schema": {
+          "const": "https://intentius.io/chant/schemas/workspace/records-review/v1/records-review.schema.json"
+        },
+        "contract": {
+          "const": 1
+        },
+        "kind": {
+          "type": "object",
+          "required": [
+            "name",
+            "schema",
+            "file"
+          ],
+          "properties": {
+            "name": {
+              "type": "string",
+              "description": "The kind's name, such as \"decision\"."
+            },
+            "schema": {
+              "type": "string",
+              "description": "The `$id` of the schema the record was validated against."
+            },
+            "file": {
+              "type": "string",
+              "description": "The kind file, relative to the repository root, with / separators."
+            }
+          }
+        },
+        "path": {
+          "type": "string",
+          "description": "The record file, relative to the repository root (the working directory outside git), with / separators."
+        },
+        "id": {
+          "type": "string",
+          "description": "The record's id."
+        },
+        "review": {
+          "type": "object",
+          "description": "The entry appended to the record's reviews, as written.",
+          "required": [
+            "reviewer",
+            "verdict",
+            "on",
+            "digest"
+          ],
+          "properties": {
+            "reviewer": {
+              "type": "string",
+              "minLength": 1,
+              "description": "The principal given with --by, as given. The write does not check who it is. With --sign, the seal lets chant workspace records check it against the signers file at base (#2687)."
+            },
+            "verdict": {
+              "enum": [
+                "agree",
+                "dissent",
+                "abstain"
+              ]
+            },
+            "note": {
+              "type": "string",
+              "description": "The note given with --note. Absent when none was given; a dissent always has one."
+            },
+            "on": {
+              "type": "string",
+              "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}$",
+              "description": "The date of the verdict, in UTC."
+            },
+            "digest": {
+              "type": "string",
+              "pattern": "^[0-9a-f]{64}$",
+              "description": "The digest of the record text the verdict judged: the lowercase hex SHA-256 of the file with LF line endings and without its reviews block (#2672), as records prints it for the record. The command changes only the reviews block, so the record keeps this digest."
+            },
+            "session": {
+              "type": "string",
+              "minLength": 1,
+              "description": "The session given with --session. Absent when none was given. Since #2693 it names an open session of a session kind whose subjects are this kind, found through the workspace declaration (session-unknown, session-not-open)."
+            },
+            "seal": {
+              "type": "object",
+              "description": "Added in contract 1 by #2687. With --sign only: an ssh signature by the key given (or git's user.signingkey) over <id>\\n<digest>\\n<verdict>\\n<reviewer>\\n<on>, in the ssh-keygen namespace chant-review. The write does not check the key against the signers file; chant workspace records reports whether the seal counts.",
+              "required": [
+                "signer",
+                "key",
+                "signature"
+              ],
+              "properties": {
+                "signer": {
+                  "type": "string",
+                  "description": "The reviewer given with --by."
+                },
+                "key": {
+                  "type": "string",
+                  "pattern": "^SHA256:[A-Za-z0-9+/]+=*$",
+                  "description": "The fingerprint of the key that signed, read back from the signature."
+                },
+                "signature": {
+                  "type": "string",
+                  "description": "The armored ssh signature."
+                }
+              }
+            }
+          }
+        },
+        "dryRun": {
+          "type": "boolean",
+          "description": "True when --dry-run was given and nothing was written."
+        },
+        "warnings": {
+          "type": "array",
+          "description": "The written record's warnings, as chant workspace records reports them. A warning never refuses a write.",
+          "items": {
+            "$ref": "#/$defs/warning"
+          }
+        },
+        "digest": {
+          "type": "string",
+          "pattern": "^[0-9a-f]{64}$",
+          "description": "Added in contract 1 by #3173. The record's digest after the write, as chant workspace records --json reports it (with --dry-run, the digest it would have). Pass it as --expect to the next amend, review or close of the record, so that write is refused with record-conflict if someone else wrote the record in between."
+        },
+        "text": {
+          "type": "string",
+          "description": "With --dry-run only: the whole text of the file the command would write."
+        },
+        "session": {
+          "type": "object",
+          "description": "Added in contract 1 by #2693, with --session only: the session record the verdict was also appended to, in the same command, so the session's verdicts list and the reviews that name the session never differ. Both files are validated before either is written.",
+          "required": [
+            "id",
+            "path",
+            "verdict"
+          ],
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "path": {
+              "type": "string",
+              "description": "The session file, relative to the repository root, with / separators."
+            },
+            "verdict": {
+              "type": "object",
+              "description": "The entry appended to the session's verdicts list (the field the session kind's session.verdicts names): the record's id, the principal given with --by, the verdict and the same digest as the review.",
+              "required": [
+                "record",
+                "principal",
+                "verdict",
+                "digest"
+              ],
+              "properties": {
+                "record": {
+                  "type": "string"
+                },
+                "principal": {
+                  "type": "string"
+                },
+                "verdict": {
+                  "enum": [
+                    "agree",
+                    "dissent",
+                    "abstain"
+                  ]
+                },
+                "digest": {
+                  "type": "string",
+                  "pattern": "^[0-9a-f]{64}$"
+                }
+              }
+            },
+            "text": {
+              "type": "string",
+              "description": "With --dry-run only: the whole text the session file would hold."
+            }
+          }
+        },
+        "error": false
+      }
+    },
+    "warning": {
+      "type": "object",
+      "required": [
+        "code",
+        "message"
+      ],
+      "properties": {
+        "code": {
+          "enum": [
+            "asset-drift",
+            "asset-missing",
+            "asset-stale",
+            "record-supersedes-pending",
+            "record-no-evidence",
+            "review-undigested",
+            "source-transcript-drift"
+          ]
+        },
+        "message": {
+          "type": "string"
+        }
+      }
+    },
+    "failure": {
+      "description": "Nothing was written. Exit code 1.",
+      "type": "object",
+      "required": [
+        "$schema",
+        "contract",
+        "error"
+      ],
+      "properties": {
+        "$schema": {
+          "const": "https://intentius.io/chant/schemas/workspace/records-review/v1/records-review.schema.json"
+        },
+        "contract": {
+          "const": 1
+        },
+        "error": {
+          "type": "object",
+          "required": [
+            "code",
+            "message"
+          ],
+          "properties": {
+            "code": {
+              "enum": [
+                "kind-unreadable",
+                "kind-invalid",
+                "schema-unreadable",
+                "schema-id-mismatch",
+                "schema-invalid",
+                "location-missing",
+                "write-usage-invalid",
+                "record-not-found",
+                "review-unsupported",
+                "record-closed",
+                "review-note-required",
+                "review-sign-failed",
+                "session-unknown",
+                "session-not-open",
+                "record-conflict",
+                "write-lock-timeout",
+                "write-lock-not-held",
+                "write-scope-member",
+                "write-scope-kind",
+                "write-scope-class-unknown",
+                "agent-unknown",
+                "principal-unidentified",
+                "record-unparseable",
+                "record-schema-invalid",
+                "record-id-duplicate",
+                "record-supersedes-unknown",
+                "record-supersedes-conflict",
+                "record-remediates-unknown",
+                "record-remediates-not-closed",
+                "record-seal-mismatch",
+                "session-seal-mismatch",
+                "session-verdict-unknown-record"
+              ]
+            },
+            "message": {
+              "type": "string",
+              "description": "What was wrong, and what to do instead when there is something, such as writing a new record that supersedes this one."
+            }
+          }
+        },
+        "conflict": {
+          "type": "object",
+          "description": "Added in contract 1 by #3173. With record-conflict only: the record as it is now. Re-read it, and write again with --expect set to digest if the change still stands.",
+          "required": [
+            "id",
+            "path",
+            "expected",
+            "digest",
+            "lastWrite"
+          ],
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "path": {
+              "type": "string",
+              "description": "The record file, from the repository root."
+            },
+            "expected": {
+              "type": "string",
+              "description": "The digest given with --expect."
+            },
+            "digest": {
+              "type": "string",
+              "pattern": "^[0-9a-f]{64}$",
+              "description": "The record's digest now."
+            },
+            "lastWrite": {
+              "description": "The last chant write of the record file, from the write journal in the git directory, while the file still holds the text it left; null when the journal does not know it.",
+              "oneOf": [
+                {
+                  "type": "null"
+                },
+                {
+                  "type": "object",
+                  "required": [
+                    "verb",
+                    "by",
+                    "agent",
+                    "at"
+                  ],
+                  "properties": {
+                    "verb": {
+                      "type": "string",
+                      "description": "The write command, such as records amend or points answer."
+                    },
+                    "by": {
+                      "type": [
+                        "string",
+                        "null"
+                      ],
+                      "description": "The principal the write named, or null when it named none."
+                    },
+                    "agent": {
+                      "type": [
+                        "string",
+                        "null"
+                      ],
+                      "description": "The agent session it was made in (CHANT_AGENT), or null."
+                    },
+                    "at": {
+                      "type": "string",
+                      "description": "When, as an ISO 8601 time."
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        },
+        "path": false
+      }
+    }
+  }
+}

package/dist/workspace/records-since.js

@@ -0,0 +1,317 @@
+/**
+ * `chant workspace records --kind <kind file> --since <rev> [--at <rev>]
+ * [--json]` (#2673, #2650 C11): what changed in a kind's records between two
+ * revisions. It reads the records at `<rev>` and at `--at` (the working tree
+ * without it), through the same reader as `records`, and lists new and
+ * removed records, state transitions, new verdicts, new supersessions and
+ * changed pins. Between a review session's open and close commits, that is
+ * what the session did.
+ *
+ * Records are matched by id. A record whose id could not be read is left
+ * out of the comparison, since nothing says which record it was before.
+ *
+ * `--since <session id>` (#2693) compares the commit a review session
+ * opened at with the commit that carries its close. The first is the
+ * record's opening revision (the kind's `session.openedRev` field). The
+ * record's closing revision (`session.closedRev`) is HEAD when `records
+ * close` wrote the close, before the caller committed it, so the close and
+ * the verdicts committed with it are in the first commit after it that
+ * changed the session file. A session written before chant wrote these
+ * fields falls back to its file's history: the commit that added it and the
+ * last commit that changed it. An open session, or one whose close is not
+ * committed yet, is compared with the working tree, and an open one says so
+ * with `since-session-open`.
+ */
+import { realpathSync } from "node:fs";
+import { relative } from "node:path";
+import { pinEntries } from "./record-assets.js";
+import { gitRoot, resolveRevision } from "./record-source.js";
+import { READ_ERROR_CODES, RecordReadError } from "./records.js";
+import { readRecordsFor, realpathOr, RECORDS_CONTRACT_VERSION } from "./records-cli.js";
+import { commitsTouching, findSessionKinds, SESSION_ID } from "./session-kinds.js";
+/** `$id` of the JSON Schema for `records --since --json`, shipped beside this file. */
+export const RECORDS_SINCE_OUTPUT_SCHEMA_ID = "https://intentius.io/chant/schemas/workspace/records-since/v1/records-since.schema.json";
+/** Why a `--since` read failed: any records read error, or a `--since` that names no commit. Closed. */
+export const RECORDS_SINCE_ERROR_CODES = [
+    ...READ_ERROR_CODES,
+    /** `--since` names no commit. */
+    "since-rev-unknown",
+    /** `--since` has a session id's shape, names no commit, and no session has the id (#2693). */
+    "since-session-unknown",
+];
+/** Why a session's comparison is not the one between its open and close commits (#2693). Closed. */
+export const RECORDS_SINCE_REASON_CODES = [
+    /** The session is open, so the comparison runs to the working tree. */
+    "since-session-open",
+];
+/** The kinds of change, in the order the output lists them. */
+export const SINCE_CHANGE_KINDS = ["new", "removed", "state", "verdict", "supersession", "pin"];
+/** The review list on a record that is not a session, when its kind declares none (#2670, #2671). */
+const REVIEWS_FIELD = "reviews";
+class SinceError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+/** Run the comparison and build the document `--json` prints. Never throws a read error. */
+export async function queryRecordsSince(query) {
+    const failure = (code, message) => ({
+        $schema: RECORDS_SINCE_OUTPUT_SCHEMA_ID,
+        contract: RECORDS_CONTRACT_VERSION,
+        error: { code, message },
+    });
+    try {
+        const found = await findSinceSession(query);
+        const since = resolveSince(query.cwd, found ? found.since : query.since, found?.session.id);
+        const at = found ? (found.at ?? undefined) : query.at;
+        const after = await readRecordsFor({ kind: query.kind, at, cwd: query.cwd });
+        let before;
+        try {
+            before = (await readRecordsFor({ kind: query.kind, at: since, cwd: query.cwd })).result.records;
+        }
+        catch (err) {
+            // A directory that did not exist yet held no records.
+            if (!(err instanceof RecordReadError) || err.code !== "location-missing")
+                throw err;
+            before = [];
+        }
+        const changes = compareRecords(after.loaded.kind, before, after.result.records);
+        const summary = Object.fromEntries(SINCE_CHANGE_KINDS.map((k) => [k, changes.filter((c) => c.change === k).length]));
+        return {
+            $schema: RECORDS_SINCE_OUTPUT_SCHEMA_ID,
+            contract: RECORDS_CONTRACT_VERSION,
+            kind: kindView(after.loaded, after.root),
+            since,
+            at: after.at,
+            ...(found ? { session: found.session } : {}),
+            changes,
+            summary,
+        };
+    }
+    catch (err) {
+        if (err instanceof SinceError)
+            return failure(err.code, err.message);
+        if (err instanceof RecordReadError)
+            return failure(err.code, err.message);
+        throw err;
+    }
+}
+function kindView(loaded, root) {
+    return { name: loaded.kind.name, schema: loaded.kind.schema.id, file: relative(root, loaded.file).split("\\").join("/") };
+}
+/**
+ * The session `query.since` names, with the revisions to compare, or null
+ * when it names none and is to be read as a revision. It is looked up only
+ * in a git repository, when it has a session id's shape, in the kind read
+ * when that is a session kind and in the session kinds the declaration
+ * names. An id-shaped value that is neither a session nor a commit is
+ * `since-session-unknown`.
+ */
+async function findSinceSession(query) {
+    const top = gitRoot(realpathOr(query.cwd));
+    if (!top || !SESSION_ID.test(query.since))
+        return null;
+    const kinds = await findSessionKinds(query.cwd, [query.kind]);
+    for (const k of kinds) {
+        let records;
+        try {
+            records = (await readRecordsFor({ kind: k.file, cwd: query.cwd })).result.records;
+        }
+        catch (err) {
+            if (err instanceof RecordReadError)
+                continue;
+            throw err;
+        }
+        const s = records.find((r) => r.id === query.since);
+        if (!s)
+            continue;
+        const decl = k.kind.session;
+        const field = (f) => (f !== undefined && typeof s.data?.[f] === "string" ? s.data[f] : null);
+        const closed = s.state !== null && (k.kind.closedStates ?? []).includes(s.state);
+        const session = { id: s.id, path: s.path, state: s.state, sinceFrom: "opened-rev", atFrom: "working-tree", reasons: [] };
+        let since = field(decl.openedRev);
+        if (since === null) {
+            since = commitsTouching(top, s.path, ["--diff-filter=A"])[0] ?? null;
+            session.sinceFrom = "history";
+            if (since === null) {
+                throw new SinceError("since-rev-unknown", `session ${s.id} (${s.path}) names no commit it opened at${decl.openedRev ? ` in ${decl.openedRev}` : ""}, and no commit added its file`);
+            }
+        }
+        let at = null;
+        if (query.at !== undefined) {
+            at = query.at;
+            session.atFrom = "at";
+        }
+        else if (closed) {
+            const closedRev = field(decl.closedRev);
+            if (closedRev !== null && /^[0-9a-f]{40,64}$/.test(closedRev)) {
+                // The oldest of these is the commit that carried the close. None yet means the close is only in the working tree.
+                at = commitsTouching(top, s.path, [`${closedRev}..HEAD`]).slice(-1)[0] ?? null;
+                session.atFrom = at === null ? "working-tree" : "close-commit";
+            }
+            else {
+                at = commitsTouching(top, s.path, ["-1"])[0] ?? null;
+                session.atFrom = at === null ? "working-tree" : "history";
+            }
+        }
+        else {
+            session.reasons.push({ code: "since-session-open", message: `session ${s.id} is ${s.state ?? "not closed"}, so it has no closing revision, and the comparison runs to the working tree` });
+        }
+        return { since, at, session };
+    }
+    try {
+        resolveRevision(top, query.since);
+        return null;
+    }
+    catch (err) {
+        if (!(err instanceof RecordReadError))
+            throw err;
+    }
+    if (kinds.length === 0)
+        return null;
+    throw new SinceError("since-session-unknown", `--since ${query.since} names no commit, and no ${[...new Set(kinds.map((k) => k.kind.name))].join(" or ")} record has that id`);
+}
+/** The full commit id `rev` names, from the repository holding `cwd`; `session` names the session it came from. */
+function resolveSince(cwd, rev, session) {
+    let dir = cwd;
+    try {
+        dir = realpathSync(cwd);
+    }
+    catch {
+        // Reported by the read that follows, if at all.
+    }
+    const top = gitRoot(dir);
+    if (!top)
+        throw new RecordReadError("not-a-git-repository", "--since reads git objects, and this directory is not in a git repository");
+    try {
+        return resolveRevision(top, rev);
+    }
+    catch (err) {
+        if (err instanceof RecordReadError && err.code === "revision-unknown") {
+            throw new SinceError("since-rev-unknown", session ? `session ${session} names ${rev}, which is no commit in this repository` : `--since ${rev} names no commit in this repository`);
+        }
+        throw err;
+    }
+}
+/** The first record with each id, in path order; records with no id are left out. */
+function byId(records) {
+    const out = new Map();
+    for (const r of records)
+        if (r.id !== null && !out.has(r.id))
+            out.set(r.id, r);
+    return out;
+}
+/**
+ * A record's verdicts: a session's own verdict list, or the review list on
+ * any other record. Two entries are the same verdict when they name the same
+ * principal, verdict, date, session and record, so a dissent that later gains
+ * `addressed_by` is not a new verdict.
+ */
+function verdicts(kind, r) {
+    const field = kind.session ? kind.session.verdicts : (kind.reviews?.field ?? REVIEWS_FIELD);
+    const list = r.data?.[field];
+    if (!Array.isArray(list))
+        return [];
+    const str = (v) => (typeof v === "string" ? v : undefined);
+    const out = [];
+    list.forEach((e, index) => {
+        if (e === null || typeof e !== "object" || Array.isArray(e))
+            return;
+        const o = e;
+        const principal = str(kind.session ? o.principal : o.reviewer) ?? null;
+        const verdict = str(o.verdict) ?? null;
+        const record = str(o.record);
+        const session = str(o.session);
+        out.push({
+            key: JSON.stringify([principal, verdict, str(o.on) ?? null, session ?? null, record ?? null]),
+            index,
+            principal,
+            verdict,
+            ...(record !== undefined ? { record } : {}),
+            ...(session !== undefined ? { session } : {}),
+        });
+    });
+    return out;
+}
+/** What changed from `before` to `after`, in the order of {@link SINCE_CHANGE_KINDS} and then by id. */
+export function compareRecords(kind, before, after) {
+    const old = byId(before);
+    const now = byId(after);
+    const ids = [...new Set([...old.keys(), ...now.keys()])].sort();
+    const out = { new: [], removed: [], state: [], verdict: [], supersession: [], pin: [] };
+    for (const id of ids) {
+        const a = old.get(id);
+        const b = now.get(id);
+        if (!a && b)
+            out.new.push({ change: "new", id, path: b.path, state: b.state });
+        if (a && !b)
+            out.removed.push({ change: "removed", id, path: a.path, state: a.state });
+        if (!b)
+            continue;
+        if (a && a.state !== b.state)
+            out.state.push({ change: "state", id, from: a.state, to: b.state });
+        // Verdicts in b beyond the ones a already had, compared as multisets.
+        const seen = new Map();
+        for (const v of a ? verdicts(kind, a) : [])
+            seen.set(v.key, (seen.get(v.key) ?? 0) + 1);
+        for (const v of verdicts(kind, b)) {
+            const left = seen.get(v.key) ?? 0;
+            if (left > 0) {
+                seen.set(v.key, left - 1);
+                continue;
+            }
+            out.verdict.push({
+                change: "verdict",
+                id,
+                principal: v.principal,
+                verdict: v.verdict,
+                index: v.index,
+                ...(v.record !== undefined ? { record: v.record } : {}),
+                ...(v.session !== undefined ? { session: v.session } : {}),
+            });
+        }
+        // Supersession as derived, so a link that only now takes effect counts.
+        if (b.supersededBy !== null && (!a || a.supersededBy !== b.supersededBy)) {
+            out.supersession.push({ change: "supersession", id: b.supersededBy, supersedes: id });
+        }
+        if (a && kind.pins) {
+            const from = new Map(pinEntries(a.data, kind.pins.field).map((p) => [p.path, p.sha256]));
+            const to = new Map(pinEntries(b.data, kind.pins.field).map((p) => [p.path, p.sha256]));
+            for (const path of [...new Set([...from.keys(), ...to.keys()])].sort()) {
+                const x = from.get(path) ?? null;
+                const y = to.get(path) ?? null;
+                if (x !== y)
+                    out.pin.push({ change: "pin", id, path, from: x, to: y });
+            }
+        }
+    }
+    out.supersession.sort((x, y) => (x.id < y.id ? -1 : x.id > y.id ? 1 : 0));
+    return SINCE_CHANGE_KINDS.flatMap((k) => out[k]);
+}
+/** The text form: one line per change and a summary. */
+export function formatSince(doc) {
+    const lines = doc.changes.map((c) => {
+        switch (c.change) {
+            case "new":
+                return `${c.id}  new, ${c.state ?? "no state"}  (${c.path})`;
+            case "removed":
+                return `${c.id}  removed, was ${c.state ?? "no state"}  (${c.path})`;
+            case "state":
+                return `${c.id}  state ${c.from ?? "none"} to ${c.to ?? "none"}`;
+            case "verdict":
+                return `${c.id}  verdict ${c.verdict ?? "-"} by ${c.principal ?? "-"}${c.record ? ` on ${c.record}` : ""}${c.session ? ` in ${c.session}` : ""}`;
+            case "supersession":
+                return `${c.id}  supersedes ${c.supersedes}`;
+            case "pin":
+                return `${c.id}  pin ${c.path} ${c.from ? c.from.slice(0, 12) : "none"} to ${c.to ? c.to.slice(0, 12) : "none"}`;
+        }
+    });
+    const s = doc.summary;
+    if (doc.session) {
+        const x = doc.session;
+        lines.unshift(`session ${x.id} (${x.state ?? "no state"}): opened at ${doc.since.slice(0, 8)} (${x.sinceFrom}), compared to ${doc.at ? `${doc.at.slice(0, 8)} (${x.atFrom})` : "the working tree"}`);
+    }
+    lines.push(`${doc.changes.length} changes since ${doc.since.slice(0, 8)}${doc.at ? ` to ${doc.at.slice(0, 8)}` : " to the working tree"}: ${s.new} new, ${s.removed} removed, ${s.state} state, ${s.verdict} verdicts, ${s.supersession} supersessions, ${s.pin} pins`);
+    return lines.join("\n");
+}