@erclx/canon 4.0.0

package/scripts/core/regen-indexes.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -e
+set -o pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
+
+source "$PROJECT_ROOT/scripts/lib/ui.sh"
+
+bun "$PROJECT_ROOT/src/cli.ts" indexes regen --root "$PROJECT_ROOT" --json >/dev/null

package/scripts/core/regen-tooling-paths.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+set -e
+set -o pipefail
+
+# Rewrites the generated path block in the shipped overwrite contract, which
+# names every file a tooling sync can replace. The category reaches past the
+# linters its name suggests, into the CI workflow, the end-to-end harness, and
+# the shell scripts under scripts/, so a reader cannot infer the list. Generating
+# it is what keeps a stack gaining a file from leaving the contract wrong.
+#
+# The stack names come from `tooling list` rather than from a directory walk,
+# so a stack the verb excludes never reaches a contract about what the verb does.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
+
+TOOLING_DIR="$PROJECT_ROOT/tooling"
+CONTRACT="$PROJECT_ROOT/claude/skills/canon-cli/SKILL.md"
+
+BEGIN="<!-- generated:tooling-paths -->"
+END="<!-- /generated:tooling-paths -->"
+
+[ -d "$TOOLING_DIR" ] || exit 0
+[ -f "$CONTRACT" ] || exit 0
+
+grep -qF "$BEGIN" "$CONTRACT" || {
+  echo "Missing $BEGIN marker in $CONTRACT" >&2
+  exit 1
+}
+
+block="$(mktemp)"
+trap 'rm -f "$block" "$CONTRACT.tmp"' EXIT
+
+{
+  echo "$BEGIN"
+  echo
+  while IFS= read -r stack; do
+    [ -d "$TOOLING_DIR/$stack/configs" ] || continue
+    echo "### $stack"
+    echo
+    while IFS= read -r rel; do
+      echo "- \`$rel\`"
+    done < <(cd "$TOOLING_DIR/$stack/configs" && find . -type f | sed 's|^\./||' | sort)
+    echo
+  done < <(bun "$PROJECT_ROOT/src/cli.ts" tooling list --json | jq -r '.stacks[].name' | sort)
+  echo "$END"
+} >"$block"
+
+# awk streams the file rather than editing in place, so a pattern that matches
+# nothing produces a file missing the block instead of an unchanged one that
+# exits zero.
+awk -v block_file="$block" -v begin="$BEGIN" -v end="$END" '
+  $0 == begin { while ((getline line < block_file) > 0) print line; skipping = 1; next }
+  $0 == end { skipping = 0; next }
+  !skipping { print }
+' "$CONTRACT" >"$CONTRACT.tmp"
+
+# The destination is a tracked file with a mode the copy must not inherit from
+# mktemp, so the content moves onto the original rather than replacing it.
+cat "$CONTRACT.tmp" >"$CONTRACT"
+rm -f "$CONTRACT.tmp"

package/scripts/core/repair-bare-flag.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# Repairs `core.bare`, which Claude Code's worktree entry leaves set in the
+# shared config with nothing restoring it. The flag strands the main worktree
+# and breaks the git reads that scope a verification run, so this runs ahead of
+# every stage rather than as one of them.
+#
+# The rule itself lives in `scripts/lib/worktree.sh`, the one bash function in
+# this repository under test, so this file is the invocation and never a second
+# copy of the guard that spares a genuinely bare repository.
+set -e
+set -o pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
+
+source "$PROJECT_ROOT/scripts/lib/ui.sh"
+source "$PROJECT_ROOT/scripts/lib/worktree.sh"
+
+repair_bare_flag "$PROJECT_ROOT"

package/scripts/core/snapshot.sh

@@ -0,0 +1,134 @@
+#!/usr/bin/env bash
+set -e
+set -o pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
+
+# shellcheck source=/dev/null
+source "$PROJECT_ROOT/scripts/lib/ui.sh"
+
+NESTED="${VERIFY_NESTED:-false}"
+
+OUTPUT_FILE=".claude/.tmp/project/PROJECT-SNAPSHOT.md"
+
+check_dependencies() {
+  command -v find >/dev/null 2>&1 || log_error "find not installed"
+}
+
+load_gitignore_patterns() {
+  if [ ! -f ".gitignore" ]; then
+    echo ""
+    return
+  fi
+  grep -v '^\s*#' .gitignore | grep -v '^\s*$' | sed 's|/$||'
+}
+
+is_ignored() {
+  local name="$1"
+  local patterns="$2"
+
+  [ "$name" = ".git" ] && return 0
+  [ "$name" = "_" ] && return 0
+
+  while IFS= read -r pattern; do
+    [ -z "$pattern" ] && continue
+    # shellcheck disable=SC2053
+    if [[ "$name" == $pattern ]]; then
+      return 0
+    fi
+  done <<<"$patterns"
+
+  return 1
+}
+
+build_tree() {
+  local dir="${1:-.}"
+  local prefix="${2:-}"
+  local patterns="${3:-}"
+  local entries=()
+
+  while IFS= read -r entry; do
+    local name
+    name=$(basename "$entry")
+    is_ignored "$name" "$patterns" && continue
+    entries+=("$entry")
+  done < <(find "$dir" -maxdepth 1 -mindepth 1 | sort)
+
+  local count=${#entries[@]}
+  local i=0
+
+  for entry in "${entries[@]}"; do
+    i=$((i + 1))
+    local name
+    name=$(basename "$entry")
+    local connector="├──"
+    local child_prefix="${prefix}│   "
+
+    if [ "$i" -eq "$count" ]; then
+      connector="└──"
+      child_prefix="${prefix}    "
+    fi
+
+    if [ -d "$entry" ]; then
+      echo "${prefix}${connector} ${name}/"
+      build_tree "$entry" "$child_prefix" "$patterns"
+    else
+      echo "${prefix}${connector} ${name}"
+    fi
+  done
+}
+
+write_snapshot() {
+  local project_name
+  project_name=$(basename "$PWD")
+  local patterns
+  patterns=$(load_gitignore_patterns)
+
+  mkdir -p "$(dirname "$OUTPUT_FILE")"
+
+  {
+    echo "# Project Snapshot: $project_name"
+    echo ""
+    echo "## Structure"
+    echo ""
+    echo '```'
+    build_tree "." "" "$patterns"
+    echo '```'
+    echo ""
+
+    if [ -f "package.json" ]; then
+      echo "## package.json"
+      echo ""
+      echo '```json'
+      cat package.json
+      echo '```'
+      echo ""
+    fi
+  } >"$OUTPUT_FILE"
+}
+
+main() {
+  check_dependencies
+
+  if [ "$NESTED" = false ]; then open_timeline; fi
+
+  log_step "Snapshot"
+  write_snapshot
+  log_info "Written to $OUTPUT_FILE"
+
+  # The whole frame goes to stderr, since the run writes its document to a file
+  # and leaves stdout carrying nothing. Edges on stdout with the body on stderr
+  # would capture as a frame with no body inside it.
+  if [ "$NESTED" = false ]; then
+    close_timeline
+    # All six are declared to scope what `set_palette` assigns, so the four this
+    # line never spells stay out of the globals a sourcing script reads.
+    # shellcheck disable=SC2034
+    local GREEN RED YELLOW WHITE GREY NC
+    set_palette 2
+    echo -e "\n${GREEN}✓ Snapshot complete${NC}" >&2
+  fi
+}
+
+main "$@"

package/scripts/core/update.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+set -e
+set -o pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
+
+source "$PROJECT_ROOT/scripts/lib/ui.sh"
+
+check_dependencies() {
+  command -v bun >/dev/null 2>&1 || log_error "bun is not installed"
+}
+
+main() {
+  check_dependencies
+
+  echo -e "${GREY}┌${NC}"
+
+  echo -e "${GREY}├${NC} ${WHITE}Interactive dependency update${NC}"
+  echo -e "${GREY}│${NC}"
+  bun update --interactive
+
+  log_step "Verifying project health"
+  if [ -f "$PROJECT_ROOT/src/cli.ts" ]; then
+    bun "$PROJECT_ROOT/src/cli.ts" gate run --nested
+    log_info "All checks passed"
+  else
+    log_warn "Verification entry point not found, skipping."
+  fi
+
+  echo -e "${GREY}└${NC}\n"
+  echo -e "${GREEN}✓ Update complete${NC}"
+}
+
+main "$@"

package/scripts/docs/list.sh

@@ -0,0 +1,165 @@
+#!/usr/bin/env bash
+set -e
+set -o pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="${PROJECT_ROOT:-$(dirname "$(dirname "$SCRIPT_DIR")")}"
+
+source "$PROJECT_ROOT/scripts/lib/ui.sh"
+source "$PROJECT_ROOT/scripts/lib/frontmatter.sh"
+
+DOCS_DIR="$PROJECT_ROOT/docs"
+CONTEXT_DIR="$PROJECT_ROOT/.claude/context"
+
+INTERNAL_TOPICS=" ci development sandbox "
+
+show_help() {
+  echo -e "${GREY}┌${NC}"
+  echo -e "${GREY}├${NC} ${WHITE}Usage:${NC} canon docs list [options]"
+  echo -e "${GREY}│${NC}"
+  echo -e "${GREY}│${NC}  ${WHITE}Options:${NC}"
+  echo -e "${GREY}│${NC}    --json       ${GREY}# Emit machine-readable JSON${NC}"
+  echo -e "${GREY}│${NC}    -h, --help   ${GREY}# Show this help message${NC}"
+  echo -e "${GREY}└${NC}"
+  exit 0
+}
+
+is_target_facing() {
+  case "$1" in
+  "Agent surface" | "Domain references") return 0 ;;
+  *) return 1 ;;
+  esac
+}
+
+is_internal_topic() {
+  case "$INTERNAL_TOPICS" in
+  *" $1 "*) return 0 ;;
+  *) return 1 ;;
+  esac
+}
+
+# Emits `name<TAB>description<TAB>category<TAB>target` per target-facing doc,
+# sorted so a domain split into a folder lands in its alphabetical place rather
+# than after every file. A folder declares its category on its own index, since
+# the allowlist is what separates a target-facing doc from a workflow one and a
+# split domain is not exempt from it.
+collect_docs() {
+  local file name description category
+  {
+    while IFS= read -r file; do
+      name=$(basename "$file" .md)
+      [ "$name" = "index" ] && continue
+      category=$(read_frontmatter_field "$file" "category")
+      is_target_facing "$category" || continue
+      description=$(read_frontmatter_field "$file" "description")
+      printf '%s\t%s\t%s\t%s\n' "$name" "$description" "$category" "docs/$name.md"
+    done < <(find "$DOCS_DIR" -maxdepth 1 -type f -name "*.md")
+
+    # A split domain is named by its folder and described by its generated
+    # index, which carries subtitle where a sibling file carries description
+    while IFS= read -r file; do
+      name=$(basename "$(dirname "$file")")
+      category=$(read_frontmatter_field "$file" "category")
+      is_target_facing "$category" || continue
+      description=$(read_frontmatter_field "$file" "subtitle")
+      printf '%s\t%s\t%s\t%s\n' "$name" "$description" "$category" "docs/$name/index.md"
+    done < <(find "$DOCS_DIR" -mindepth 2 -maxdepth 2 -type f -name "index.md")
+  } | sort
+}
+
+# Emits `name<TAB>description<TAB>target` per context entry, sorted so a domain
+# split into a folder lands in its alphabetical place rather than after every
+# file. Matches listTopics in src/docs/read.ts, which sorts both together.
+collect_context() {
+  local file name description
+  {
+    while IFS= read -r file; do
+      name=$(basename "$file" .md)
+      [ "$name" = "index" ] && continue
+      is_internal_topic "$name" && continue
+      description=$(read_frontmatter_field "$file" "description")
+      printf '%s\t%s\t%s\n' "$name" "$description" ".claude/context/$name.md"
+    done < <(find "$CONTEXT_DIR" -maxdepth 1 -type f -name "*.md")
+
+    # A split domain is named by its folder and described by its generated
+    # index, which carries subtitle where a sibling file carries description
+    while IFS= read -r file; do
+      name=$(basename "$(dirname "$file")")
+      is_internal_topic "$name" && continue
+      description=$(read_frontmatter_field "$file" "subtitle")
+      printf '%s\t%s\t%s\n' "$name" "$description" ".claude/context/$name/index.md"
+    done < <(find "$CONTEXT_DIR" -mindepth 2 -maxdepth 2 -type f -name "index.md")
+  } | sort
+}
+
+list_text() {
+  local name description category target
+  log_step "Docs"
+  while IFS=$'\t' read -r name description category target; do
+    log_info "$name : $description"
+  done < <(collect_docs)
+
+  # Absent in a registry install, which ships docs/ without .claude/
+  if [ -d "$CONTEXT_DIR" ]; then
+    log_step "Domain context"
+    while IFS=$'\t' read -r name description target; do
+      log_info "$name : $description"
+    done < <(collect_context)
+  fi
+}
+
+emit_json_entry() {
+  local name="$1" description="$2" category="$3" target="$4"
+  [ "$JSON_FIRST" -eq 0 ] && printf ','
+  jq -nc \
+    --arg name "$name" \
+    --arg description "$description" \
+    --arg category "$category" \
+    --arg target "$target" \
+    '{name: $name, description: $description, category: $category, target: $target}'
+  JSON_FIRST=0
+}
+
+list_json() {
+  local name description category target
+  JSON_FIRST=1
+  printf '['
+  while IFS=$'\t' read -r name description category target; do
+    emit_json_entry "$name" "$description" "$category" "$target"
+  done < <(collect_docs)
+
+  if [ -d "$CONTEXT_DIR" ]; then
+    while IFS=$'\t' read -r name description target; do
+      emit_json_entry "$name" "$description" "" "$target"
+    done < <(collect_context)
+  fi
+  printf ']'
+}
+
+main() {
+  local json=0
+
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+    -h | --help) show_help ;;
+    --json)
+      json=1
+      shift
+      ;;
+    *) log_error "Unknown option: $1" ;;
+    esac
+  done
+
+  trap close_timeline EXIT
+
+  if [ "$json" -eq 1 ]; then
+    printf '{"docs":'
+    list_json
+    printf '}\n'
+    exit 0
+  fi
+
+  list_text
+}
+
+main "$@"

package/scripts/lib/frontmatter.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+# Reads one frontmatter field from a markdown file.
+#
+# Kept in bash because the list commands call it once per field per file
+# inside a loop, where shelling into the CLI would cost a process per read.
+# Index logic is TypeScript, in src/indexes/, and does not belong here.
+read_frontmatter_field() {
+  local file="$1"
+  local key="$2"
+  awk -v key="$key" '
+    NR == 1 && /^---$/ { in_fm = 1; next }
+    in_fm && /^---$/ { exit }
+    in_fm {
+      prefix = key ": "
+      if (index($0, prefix) == 1) {
+        val = substr($0, length(prefix) + 1)
+        if (length(val) >= 2) {
+          first = substr(val, 1, 1)
+          last = substr(val, length(val), 1)
+          if ((first == "\"" && last == "\"") || (first == "'\''" && last == "'\''")) {
+            val = substr(val, 2, length(val) - 2)
+          }
+        }
+        print val
+        exit
+      }
+    }
+  ' "$file"
+}

package/scripts/lib/gov.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+
+# Sole survivor of the gov lib. Called once per rule file inside install and
+# sandbox loops, where routing through the CLI would cost a process per file.
+
+rule_subdir() {
+  local src="$1"
+  local rules_root="${2:-$PROJECT_ROOT/governance/rules}"
+  local rel="${src#"$rules_root/"}"
+  local subdir
+  subdir=$(dirname "$rel")
+  [ "$subdir" = "." ] && subdir=""
+  echo "$subdir"
+}

package/scripts/lib/sandbox-fixtures.sh

@@ -0,0 +1,191 @@
+#!/usr/bin/env bash
+
+# Fixture files carry this suffix so the repository's own checks ignore them.
+# A stored `index.md.fixture` is not an `index.md`, so the index walker, prettier,
+# shfmt, and shellcheck all skip it and the bytes reach the sandbox unmodified.
+FIXTURE_SUFFIX=".fixture"
+
+# The tree mirrors the scenario path, so `category` and `scenario` together match
+# `scripts/sandbox/<category>/<scenario>.sh`. Both segments are load-bearing:
+# four scenario basenames repeat across categories (`claude`, `docs`, `review`,
+# `sync`), and `docs` is also a category of its own.
+fixture_stage_dir() {
+  local category="$1"
+  local scenario="$2"
+  local arm="$3"
+  local stage="$4"
+  echo "$PROJECT_ROOT/scripts/sandbox/fixtures/$category/$scenario/$arm/$stage"
+}
+
+list_fixture_files() {
+  local source_dir="$1"
+  find "$source_dir" -type f -name "*$FIXTURE_SUFFIX" -print0 | sort -z
+}
+
+count_fixture_files() {
+  local source_dir="$1"
+  if [ ! -d "$source_dir" ]; then
+    echo 0
+    return 0
+  fi
+  find "$source_dir" -type f -name "*$FIXTURE_SUFFIX" | wc -l
+}
+
+# The copy loops match on the suffix, so a file without one would be skipped in
+# silence and the scenario would provision a tree it was never meant to have.
+assert_fixtures_suffixed() {
+  local source_dir="$1"
+  [ -d "$source_dir" ] || return 0
+
+  local stray
+  stray="$(find "$source_dir" -type f -not -name "*$FIXTURE_SUFFIX" | sort | tr '\n' ' ')"
+  [ -z "$stray" ] || log_error "Fixture missing the $FIXTURE_SUFFIX suffix: $stray"
+}
+
+fixture_target_path() {
+  local source_dir="$1"
+  local source_file="$2"
+  local relative="${source_file#"$source_dir"/}"
+  echo "${relative%"$FIXTURE_SUFFIX"}"
+}
+
+create_from_fixtures() {
+  local source_dir="$1"
+  [ -d "$source_dir" ] || return 0
+
+  local source_file target
+  while IFS= read -r -d '' source_file; do
+    target="$(fixture_target_path "$source_dir" "$source_file")"
+    mkdir -p "$(dirname "$target")"
+    cp "$source_file" "$target"
+  done < <(list_fixture_files "$source_dir")
+}
+
+# An append fixture extends a file the anchor or the injected seeds already
+# provide. A missing target means that upstream shape changed, so fail rather
+# than create the file and silently alter what the scenario provisions.
+append_from_fixtures() {
+  local source_dir="$1"
+  [ -d "$source_dir" ] || return 0
+
+  local source_file target
+  while IFS= read -r -d '' source_file; do
+    target="$(fixture_target_path "$source_dir" "$source_file")"
+    if [ ! -f "$target" ]; then
+      log_error "Append fixture has no target: $target"
+    fi
+    cat "$source_file" >>"$target"
+  done < <(list_fixture_files "$source_dir")
+}
+
+# Stages the first `count` markdown files the toolkit ships for a domain into
+# `dest`, flattening any source subfolder. Source rather than fixture tree,
+# because an arm modelling a real install wants the files a target actually
+# received and a copy under `fixtures/` would drift from them silently.
+#
+# The flattening is load-bearing rather than incidental. Both `detectUnmigrated`
+# and the sync engine match a target file to its source by basename against the
+# flat domain root, so a file lifted out of a source subfolder such as `bundled/`
+# has no flat sibling and reads as project-authored. An arm staging one claims a
+# drift or an unmigrated domain it did not stage.
+stage_toolkit_markdown() {
+  local src="$1"
+  local dest="$2"
+  local count="$3"
+
+  mkdir -p "$dest"
+  while IFS= read -r file; do
+    cp "$file" "$dest/$(basename "$file")"
+  done < <(find "$src" -maxdepth 1 -type f -name "*.md" ! -name "index.md" | sort | head -n "$count")
+}
+
+# The newest top-level path history records a deletion under that the toolkit no
+# longer ships. Read from history rather than hardcoded, so an arm stages a root
+# the walk will actually recognize instead of a name that has since come back.
+# `prompts` is preferred because it is the case measured in a real target, and
+# any other dropped root exercises the same walk.
+pick_dropped_root() {
+  local preferred="prompts"
+  local first=""
+  local candidate
+
+  while IFS= read -r candidate; do
+    [ -e "$PROJECT_ROOT/$candidate" ] && continue
+    [ "$candidate" = "$preferred" ] && {
+      echo "$preferred"
+      return 0
+    }
+    [ -n "$first" ] || first="$candidate"
+  done < <(git -C "$PROJECT_ROOT" log --all --diff-filter=D --name-only --format= |
+    awk -F/ 'NF > 1 { print $1 }' | sort -u)
+
+  echo "$first"
+}
+
+# Restores one file's exact published bytes from the commit before it was
+# deleted. Content is what the attribution matches on, so a file written by hand
+# would report unattributed and an arm would assert the wrong verdict.
+#
+# Both reads take the whole listing through a process substitution rather than a
+# pipeline ending in an early exit. `set -o pipefail` is on, and a `grep -m 1`
+# that matches the first line closes the pipe while git is still writing, so the
+# substitution returns git's SIGPIPE status and the arm fails on a listing it
+# actually read.
+restore_dropped_file() {
+  local root="$1"
+  local rel="" commit="" line
+
+  while IFS= read -r line; do
+    case "$line" in
+    "$root"/*)
+      rel="$line"
+      break
+      ;;
+    esac
+  done < <(git -C "$PROJECT_ROOT" log --all --diff-filter=D --name-only \
+    --format= -- "$root/")
+
+  [ -n "$rel" ] || return 1
+
+  while IFS= read -r line; do
+    commit="$line"
+    break
+  done < <(git -C "$PROJECT_ROOT" log --all --diff-filter=D --format=%H -- "$rel")
+
+  [ -n "$commit" ] || return 1
+
+  mkdir -p "$(dirname "$rel")"
+  git -C "$PROJECT_ROOT" show "$commit^:$rel" >"$rel" || return 1
+
+  echo "$rel"
+}
+
+# Stages one step of a scenario arm into the sandbox working directory.
+# Scenarios call this once per step so their own git operations stay between
+# the steps, where they are visible.
+stage_fixtures() {
+  local category="$1"
+  local scenario="$2"
+  local arm="$3"
+  local stage="$4"
+
+  local stage_dir
+  stage_dir="$(fixture_stage_dir "$category" "$scenario" "$arm" "$stage")"
+
+  if [ ! -d "$stage_dir" ]; then
+    log_error "Fixture stage not found: $category/$scenario/$arm/$stage"
+  fi
+
+  assert_fixtures_suffixed "$stage_dir/create"
+  assert_fixtures_suffixed "$stage_dir/append"
+
+  local staged
+  staged=$(($(count_fixture_files "$stage_dir/create") + \
+  $(count_fixture_files "$stage_dir/append")))
+  if [ "$staged" -eq 0 ]; then
+    log_error "Fixture stage provisions nothing: $category/$scenario/$arm/$stage"
+  fi
+
+  create_from_fixtures "$stage_dir/create"
+  append_from_fixtures "$stage_dir/append"
+}