@rubytech/create-maxy-code 0.1.485 → 0.1.487

package/payload/platform/scripts/__tests__/account-schema-owned-dirs.test.sh

@@ -110,31 +110,46 @@ merge_owned_dirs_into_schema "$A_TB" >/dev/null
 ALLOWED_TB="$(awk '/^```allowed-top-level$/{f=1;next} /^```$/{f=0} f' "$A_TB/SCHEMA.md")"
 assert_grep "ledger" "$ALLOWED_TB" "shapeb-allowlist-has-ledger"
 
-# --- construction vertical: domain buckets derived, no sites-collision ---
+# --- construction vertical: root buckets derived, job-owned entities nested ---
 T_C="$(make_vertical_tree '["sitedesk"]' 'schema-construction')"; A_C="$(make_account "$T_C")"
 export PROJECT_DIR="$T_C/platform"
 OUT_C="$(merge_owned_dirs_into_schema "$A_C")"
 # Match a non-empty derived list, not the bare key (which prints even for zero).
 assert_grep "domainBuckets=jobs" "$OUT_C" "con-domain-log"
+# Summary reports the full root set and the job-owned entities with their parent.
+assert_grep "roots=jobs,customers,customer-sites,assets,parts,ppm-contracts" "$OUT_C" "con-roots-log"
+assert_grep "nested=Visit<-Job,Quote<-Job,PurchaseOrder<-Job" "$OUT_C" "con-nested-log"
 ALLOWED_C="$(awk '/^```allowed-top-level$/{f=1;next} /^```$/{f=0} f' "$A_C/SCHEMA.md")"
-for d in jobs customers customer-sites assets visits quotes purchase-orders ppm-contracts; do
+# Root entities (blank Owner) get a top-level bucket.
+for d in jobs customers customer-sites assets parts ppm-contracts; do
   assert_grep "$d" "$ALLOWED_C" "con-allow-$d"
 done
+# Job-owned entities (Owner=Job) do NOT get a root bucket.
+for d in visits quotes purchase-orders; do
+  assert_nogrep "$d" "$ALLOWED_C" "con-noroot-$d"
+done
 assert_nogrep "whatsapp-groups" "$ALLOWED_C" "con-no-transport-bucket"
 assert_grep "customer-sites" "$ALLOWED_C" "con-site-renamed"
-assert_grep "Domain entity buckets" "$(cat "$A_C/SCHEMA.md")" "con-region"
+SCHEMA_C="$(cat "$A_C/SCHEMA.md")"
+assert_grep "Domain entity buckets" "$SCHEMA_C" "con-region"
+# The descriptive region tells the agent where a job-owned entity's records live.
+assert_grep '`Quote` records live under `jobs/` (owned by `Job`), not a root bucket.' "$SCHEMA_C" "con-nested-line"
 B_C="$(shasum "$A_C/SCHEMA.md" | awk '{print $1}')"
 merge_owned_dirs_into_schema "$A_C" >/dev/null
 assert_eq "$(shasum "$A_C/SCHEMA.md" | awk '{print $1}')" "$B_C" "con-idempotent"
 
-# --- estate-agent vertical: its own buckets, not SiteDesk's ---
+# --- estate-agent vertical: root buckets only, listing-owned entities nested ---
 T_E="$(make_vertical_tree '["real-agent"]' 'schema-estate-agent')"; A_E="$(make_account "$T_E")"
 export PROJECT_DIR="$T_E/platform"
 merge_owned_dirs_into_schema "$A_E" >/dev/null
 ALLOWED_E="$(awk '/^```allowed-top-level$/{f=1;next} /^```$/{f=0} f' "$A_E/SCHEMA.md")"
-for d in properties listings viewings offers; do
+# Root entities get a bucket; Listing-owned Viewing/Offer do not.
+for d in properties listings; do
   assert_grep "$d" "$ALLOWED_E" "ea-allow-$d"
 done
+for d in viewings offers; do
+  assert_nogrep "$d" "$ALLOWED_E" "ea-noroot-$d"
+done
 assert_nogrep "jobs" "$ALLOWED_E" "ea-no-sitedesk-jobs"
 
 # --- no vertical declared: generic base only ---
@@ -145,14 +160,68 @@ ALLOWED_N="$(awk '/^```allowed-top-level$/{f=1;next} /^```$/{f=0} f' "$A_N/SCHEM
 assert_nogrep "jobs" "$ALLOWED_N" "novert-no-domain"
 assert_nogrep "Domain entity buckets" "$(cat "$A_N/SCHEMA.md")" "novert-no-region"
 
-# --- reconcile reports each ontology entity present/absent ---
+# --- reconcile: root entity present/absent, job-owned entity never at root ---
 A_RCD="$(make_account "$T_C")"
 export PROJECT_DIR="$T_C/platform"
 RCD_BEFORE="$(PROJECT_DIR="$PROJECT_DIR" python3 "$PLAT_SCRIPTS/lib/account-schema-owned-dirs.py" reconcile "$A_RCD")"
 assert_grep "ontologyEntity=Job bucket=jobs present=false" "$RCD_BEFORE" "rcd-job-absent"
+# A job-owned entity is reported as not-expected-at-root, not as a plain bucket.
+assert_grep "ontologyEntity=Quote owner=Job bucket=quotes expectedAtRoot=false stray=false" "$RCD_BEFORE" "rcd-quote-nested"
 merge_owned_dirs_into_schema "$A_RCD" >/dev/null
 RCD_AFTER="$(PROJECT_DIR="$PROJECT_DIR" python3 "$PLAT_SCRIPTS/lib/account-schema-owned-dirs.py" reconcile "$A_RCD")"
 assert_grep "ontologyEntity=Job bucket=jobs present=true" "$RCD_AFTER" "rcd-job-present"
+# After a clean merge the job-owned bucket is still absent from root (no stray).
+assert_grep "ontologyEntity=Quote owner=Job bucket=quotes expectedAtRoot=false stray=false" "$RCD_AFTER" "rcd-quote-no-stray"
+
+# --- reconcile: a pre-fix account still listing a job-owned bucket at root is a stray ---
+A_STRAY="$(make_account "$T_C")"
+export PROJECT_DIR="$T_C/platform"
+# Seed the old flat-rule layout: inject `quotes` into the allowed-top-level fence.
+awk '/^projects$/{print; print "quotes"; next} {print}' "$A_STRAY/SCHEMA.md" > "$A_STRAY/SCHEMA.md.tmp" && mv "$A_STRAY/SCHEMA.md.tmp" "$A_STRAY/SCHEMA.md"
+RC_STRAY="$(PROJECT_DIR="$PROJECT_DIR" python3 "$PLAT_SCRIPTS/lib/account-schema-owned-dirs.py" reconcile "$A_STRAY")"
+assert_grep "ontologyEntity=Quote owner=Job bucket=quotes expectedAtRoot=false stray=true" "$RC_STRAY" "rcd-quote-stray"
+
+# insert_stray <schema_path> <name>: add <name> as the first entry inside the
+# allowed-top-level fence (simulates an account whose list carries a bucket no
+# longer in the ontology).
+insert_stray() {
+  awk -v n="$2" '{print} /^```allowed-top-level$/{print n}' "$1" > "$1.tmp" && mv "$1.tmp" "$1"
+}
+
+# --- prune: stale bucket, absent on disk -> removed from list + logged ---
+T_PRUNE="$(make_vertical_tree '["sitedesk"]' 'schema-construction')"
+A_P="$(make_account "$T_PRUNE")"; export PROJECT_DIR="$T_PRUNE/platform"
+insert_stray "$A_P/SCHEMA.md" "inbound-invoices"
+OUT_P="$(merge_owned_dirs_into_schema "$A_P")"
+ALLOWED_P="$(awk '/^```allowed-top-level$/{f=1;next} /^```$/{f=0} f' "$A_P/SCHEMA.md")"
+assert_nogrep "inbound-invoices" "$ALLOWED_P" "prune-empty-removed-from-list"
+assert_grep "removed=inbound-invoices" "$OUT_P" "prune-empty-logged"
+
+# --- keep: stale bucket that holds files -> retained + keptPopulated ---
+T_KEEP="$(make_vertical_tree '["sitedesk"]' 'schema-construction')"
+A_K="$(make_account "$T_KEEP")"; export PROJECT_DIR="$T_KEEP/platform"
+insert_stray "$A_K/SCHEMA.md" "inbound-invoices"
+mkdir -p "$A_K/inbound-invoices"; echo "stamp" > "$A_K/inbound-invoices/stamp_invoice.py"
+OUT_K="$(merge_owned_dirs_into_schema "$A_K")"
+ALLOWED_K="$(awk '/^```allowed-top-level$/{f=1;next} /^```$/{f=0} f' "$A_K/SCHEMA.md")"
+assert_grep "inbound-invoices" "$ALLOWED_K" "keep-populated-retained"
+assert_grep "keptPopulated=inbound-invoices" "$OUT_K" "keep-populated-logged"
+assert_nogrep "removed=inbound-invoices" "$OUT_K" "keep-populated-not-in-removed"
+
+# --- fixed-seed survival: empty base dir is never pruned ---
+T_SEED="$(make_tree '[]')"; A_S="$(make_account "$T_SEED")"; export PROJECT_DIR="$T_SEED/platform"
+OUT_S="$(merge_owned_dirs_into_schema "$A_S")"
+ALLOWED_S="$(awk '/^```allowed-top-level$/{f=1;next} /^```$/{f=0} f' "$A_S/SCHEMA.md")"
+for d in documents url-get .git output; do
+  assert_grep "$d" "$ALLOWED_S" "seed-survives-$d"
+done
+assert_grep "removed=none" "$OUT_S" "seed-nothing-removed"
+
+# --- idempotency after a prune: second run byte-identical (same brand) ---
+export PROJECT_DIR="$T_PRUNE/platform"
+B_P="$(shasum "$A_P/SCHEMA.md" | awk '{print $1}')"
+merge_owned_dirs_into_schema "$A_P" >/dev/null
+assert_eq "$(shasum "$A_P/SCHEMA.md" | awk '{print $1}')" "$B_P" "prune-idempotent"
 
 echo "PASS=$PASS FAIL=$FAIL"
 if [ "$FAIL" -ne 0 ]; then printf '%s\n' "${FAILED[@]}"; exit 1; fi

package/payload/platform/scripts/lib/account-schema-owned-dirs.py

@@ -24,9 +24,35 @@ MARK_END = "<!-- plugin-owned-dirs:end -->"
 ONT_START = "<!-- ontology-buckets:start -->"
 ONT_END = "<!-- ontology-buckets:end -->"
 
+# Base top-level names shipped in the account template plus `.quarantine`. This
+# set is prune-protection only: a reconcile never *adds* a missing seed entry,
+# it only shields a listed base dir from being flagged stale. Source (verbatim):
+# docs/superpowers/plans/2026-06-23-account-filesystem-schema.md allowed-top-level.
+FIXED_SEED = frozenset({
+    "projects", "contacts", "documents", "url-get", "output", "generated",
+    "extracted", "uploads", "agents", "specialists", "sites", "public",
+    "cache", "secrets", "state", "logs", "tmp", "SCHEMA.md", "account.json",
+    "AGENTS.md", ".claude", ".git", ".quarantine",
+})
+
 LABEL_DIR_OVERRIDES = {"Site": "customer-sites"}
 
 
+def _dir_holds_files(account_dir, name):
+    """True iff account_dir/<name> carries file content: a non-empty regular
+    file, or a directory whose subtree contains at least one regular file.
+    Absent path, empty dir, or a dir tree with no files -> False (prunable)."""
+    path = os.path.join(account_dir, name)
+    if not os.path.exists(path):
+        return False
+    if os.path.isfile(path):
+        return os.path.getsize(path) > 0
+    for _root, _dirs, files in os.walk(path):
+        if files:
+            return True
+    return False
+
+
 def _label_to_dir(label):
     """Map a Neo4j label to its file-schema bucket dir: kebab-case-plural,
     lowercased. camelCase word boundaries split on case. One override:
@@ -147,11 +173,14 @@ def resolve(project_dir):
 
 
 def _top_level_labels(schema_path):
-    """Extract operator-entry labels from the entity table under the
+    """Extract (label, owner) rows from the entity table under the
     '## Top-level node types' heading of a vertical schema file. A row is
     included iff its 'Schema.org Type' cell is a schema:-namespaced type
-    (excludes transport labels such as WhatsAppGroup -> cdm:Channel). Returns
-    labels in table order. No such heading -> empty list."""
+    (excludes transport labels such as WhatsAppGroup -> cdm:Channel). `owner`
+    is the containment parent from the 'Owner' column: None when the table has
+    no Owner column, '' when the column is present but the cell is blank (a root
+    entity), else the parent label (a contained entity). Returns rows in table
+    order. No such heading -> empty list."""
     try:
         with open(schema_path) as f:
             lines = f.read().split("\n")
@@ -176,6 +205,8 @@ def _top_level_labels(schema_path):
     cols = [c.strip() for c in lines[hdr].strip().strip("|").split("|")]
     label_i = cols.index("Neo4j Label")
     type_i = cols.index("Schema.org Type")
+    owner_i = cols.index("Owner") if "Owner" in cols else None
+    need = max(label_i, type_i, owner_i if owner_i is not None else 0)
     out = []
     for k in range(hdr + 2, len(lines)):  # +2 skips the header separator row
         row = lines[k]
@@ -184,19 +215,24 @@ def _top_level_labels(schema_path):
         if "|" not in row or not row.strip():
             break
         cells = [c.strip() for c in row.strip().strip("|").split("|")]
-        if len(cells) <= max(label_i, type_i):
+        if len(cells) <= need:
             continue
         label = cells[label_i].strip("`").strip()
         stype = cells[type_i].strip("`").strip()
-        if label and stype.startswith("schema:"):
-            out.append(label)
+        if not (label and stype.startswith("schema:")):
+            continue
+        owner = None if owner_i is None else cells[owner_i].strip("`").strip()
+        out.append((label, owner))
     return out
 
 
 def resolve_domain_buckets(project_dir):
     """Domain operator-entity buckets derived from the brand's vertical
-    ontology. Returns [{dir, label}] in table order, deduped by dir. Empty when
-    the brand declares no vertical or the vertical file has no top-level
+    ontology. Returns [{dir, label, owner}] in table order, deduped by dir.
+    `owner` is None (the vertical table has no Owner column), '' (a root entity
+    that owns a top-level bucket), or the parent label (a contained entity that
+    gets no root bucket, its records living under the parent's folder). Empty
+    when the brand declares no vertical or the vertical file has no top-level
     section."""
     vertical = _read_vertical(project_dir)
     if not vertical:
@@ -204,15 +240,22 @@ def resolve_domain_buckets(project_dir):
     schema_path = os.path.join(project_dir, "plugins", "memory", "references", vertical + ".md")
     seen = set()
     out = []
-    for label in _top_level_labels(schema_path):
+    for label, owner in _top_level_labels(schema_path):
         d = _label_to_dir(label)
         if d in seen:
             continue
         seen.add(d)
-        out.append({"dir": d, "label": label})
+        out.append({"dir": d, "label": label, "owner": owner})
     return out
 
 
+def _is_root(owner):
+    """A domain bucket is a root (own top-level dir) when its Owner is blank
+    ('') or the vertical declares no Owner column at all (None). A non-empty
+    owner names the containing parent, so the entity nests and emits no root."""
+    return owner is None or owner == ""
+
+
 def _allowed_block(text):
     """Return (list_of_entries, start_idx, end_idx) for the fenced
     allowed-top-level block. end_idx is the closing-fence line index."""
@@ -246,28 +289,49 @@ def merge(project_dir, account_dir):
     domain = resolve_domain_buckets(project_dir)
     schema_path = os.path.join(account_dir, "SCHEMA.md")
     if not os.path.isfile(schema_path):
-        print(f"brand={brand} added=none domainBuckets=none")
+        print(f"brand={brand} added=none domainBuckets=none removed=none keptPopulated=none")
         return
     with open(schema_path) as f:
         text = f.read()
     entries, start, end = _allowed_block(text)
     added = []
     added_domain = []
+    removed = []
+    kept_populated = []
     if entries is not None:
         present = set(entries)
-        lines = text.split("\n")
+        # Only ROOT domain buckets belong at the account root; a contained
+        # entity (non-blank Owner) nests under its owner and is not a target,
+        # so a pre-fix account's empty owned bucket prunes while a populated one
+        # is kept-and-logged like any other stale bucket.
+        target = FIXED_SEED | {e["dir"] for e in owned} | {b["dir"] for b in domain if _is_root(b["owner"])}
+        # Reconcile existing entries: keep in-target; keep populated strays
+        # (logged); drop empty/absent strays (logged).
+        new_entries = []
+        for entry in entries:
+            if entry in target:
+                new_entries.append(entry)
+            elif _dir_holds_files(account_dir, entry):
+                new_entries.append(entry)
+                kept_populated.append(entry)
+            else:
+                removed.append(entry)
+        # Append newly-projected owned then domain dirs not already present.
         insert = []
         for e in owned:
             if e["dir"] not in present and e["dir"] not in insert:
                 insert.append(e["dir"])
                 added.append(e["dir"])
         for b in domain:
+            if not _is_root(b["owner"]):
+                continue  # contained entity: no root bucket, nests under its owner
             if b["dir"] not in present and b["dir"] not in insert:
                 insert.append(b["dir"])
                 added_domain.append(b["dir"])
-        if insert:
-            lines[end:end] = insert
-            text = "\n".join(lines)
+        new_entries.extend(insert)
+        lines = text.split("\n")
+        lines[start + 1:end] = new_entries
+        text = "\n".join(lines)
     # Regenerate both descriptive regions wholesale (idempotent).
     text = _strip_region(text, MARK_START, MARK_END)
     text = _strip_region(text, ONT_START, ONT_END)
@@ -284,20 +348,33 @@ def merge(project_dir, account_dir):
     owned_dirs = {e["dir"] for e in owned}
     # A dir already claimed by a plugin (described in the plugin-owned region)
     # is not also described here, so a name collision cannot double-describe.
-    domain_region = [b for b in domain if b["dir"] not in owned_dirs]
-    if domain_region:
+    described = [b for b in domain if b["dir"] not in owned_dirs]
+    root_described = [b for b in described if _is_root(b["owner"])]
+    nested_described = [b for b in described if not _is_root(b["owner"])]
+    if root_described or nested_described:
         region = [ONT_START, "## Domain entity buckets (from the graph ontology)", "",
                   "One bucket per top-level operator-entry node type of this brand's",
                   "business ontology. File a job's artifacts under its entity folder;",
-                  "the folder may hold a subtree.", ""]
-        for b in domain_region:
+                  "the folder may hold a subtree. A contained entity has no root",
+                  "bucket; its records live under the owning entity's folder.", ""]
+        for b in root_described:
             region.append(f"- `{b['dir']}/` - one folder per {b['label']} record.")
+        for b in nested_described:
+            parent_dir = _label_to_dir(b["owner"])
+            region.append(f"- `{b['label']}` records live under `{parent_dir}/` "
+                          f"(owned by `{b['owner']}`), not a root bucket.")
         region.append(ONT_END)
         text = text.rstrip("\n") + "\n\n" + "\n".join(region) + "\n"
     with open(schema_path, "w") as f:
         f.write(text)
+    root_dirs = [b["dir"] for b in domain if _is_root(b["owner"])]
+    nested_pairs = [f"{b['label']}<-{b['owner']}" for b in domain if not _is_root(b["owner"])]
     print(f"brand={brand} added={','.join(added) if added else 'none'} "
-          f"domainBuckets={','.join(added_domain) if added_domain else 'none'}")
+          f"domainBuckets={','.join(added_domain) if added_domain else 'none'} "
+          f"removed={','.join(removed) if removed else 'none'} "
+          f"keptPopulated={','.join(kept_populated) if kept_populated else 'none'} "
+          f"roots={','.join(root_dirs) if root_dirs else 'none'} "
+          f"nested={','.join(nested_pairs) if nested_pairs else 'none'}")
 
 
 def reconcile(project_dir, account_dir):
@@ -316,9 +393,21 @@ def reconcile(project_dir, account_dir):
     domain = resolve_domain_buckets(project_dir)
     if vertical and not domain:
         print(f"brand={brand} ontologyVertical={vertical} topLevelSection=absent")
+    # A vertical whose top-level table carries no Owner column cannot state
+    # containment; every entity falls back to root, but loudly, never silently.
+    if vertical and any(b["owner"] is None for b in domain):
+        print(f"brand={brand} ontologyVertical={vertical} owner-source=absent")
     for b in domain:
-        is_present = "true" if b["dir"] in present else "false"
-        print(f"brand={brand} ontologyEntity={b['label']} bucket={b['dir']} present={is_present}")
+        if _is_root(b["owner"]):
+            is_present = "true" if b["dir"] in present else "false"
+            print(f"brand={brand} ontologyEntity={b['label']} bucket={b['dir']} present={is_present}")
+        else:
+            # Contained entity: no root bucket expected. A bucket still listed at
+            # root is a pre-fix stray the standing fs-reconcile quarantines once
+            # the owned bucket leaves the allowed set (unless it holds files).
+            is_stray = "true" if b["dir"] in present else "false"
+            print(f"brand={brand} ontologyEntity={b['label']} owner={b['owner']} "
+                  f"bucket={b['dir']} expectedAtRoot=false stray={is_stray}")
 
 
 def main():

package/payload/platform/scripts/lib/provision-account-dir.sh

@@ -86,7 +86,8 @@ provision_account_dir() {
       {
         "matcher": "Bash",
         "hooks": [
-          { "type": "command", "command": "bash $HOOKS_PATH/archive-ingest-surface-gate.sh" }
+          { "type": "command", "command": "bash $HOOKS_PATH/archive-ingest-surface-gate.sh" },
+          { "type": "command", "command": "bash $HOOKS_PATH/fs-schema-guard-bash-pre.sh" }
         ]
       },
       {
@@ -115,6 +116,12 @@ provision_account_dir() {
       }
     ],
     "PostToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          { "type": "command", "command": "bash $HOOKS_PATH/fs-schema-guard-bash-post.sh" }
+        ]
+      },
       {
         "matcher": "Agent",
         "hooks": [

package/payload/platform/services/claude-session-manager/dist/account-dir-schema-reconcile.d.ts

@@ -0,0 +1,39 @@
+export interface ReconcileCounts {
+    strayTopLevel: number;
+    overDeep: number;
+    quarantined: number;
+    badName: number;
+}
+/** The single per-run summary line body. A non-zero count is the standing signal
+ *  that an agent authored folders the hard guards could not prevent. Pure
+ *  formatter so the emitter and its test share one wording. */
+export declare function formatReconcileLine(c: ReconcileCounts): string;
+/** Parse the fenced ```allowed-top-level block from an account's SCHEMA.md —
+ *  the same structured set fs-schema-guard.sh parses with awk. Returns the
+ *  entry names (blank lines dropped). An absent block yields an empty set. */
+export declare function parseAllowedTopLevel(schemaText: string): Set<string>;
+/** Reconcile one account dir. Reads its SCHEMA.md allowed set; an absent/empty
+ *  set skips the account (fail open, like the hook — an un-seeded legacy account
+ *  must not have its whole root quarantined). Moves stray top-level entries to
+ *  .quarantine/ with a manifest line; counts over-deep files without moving. */
+export declare function reconcileAccount(accountDir: string, now: () => number): ReconcileCounts;
+export interface ReconcileDeps {
+    accountsRoot: string;
+    logger: (line: string) => void;
+    now?: () => number;
+}
+/** One reconcile pass over every account under the accounts root, then emit the
+ *  single summary line. An account is any child dir with an account.json (the
+ *  account marker the census uses). Per-account errors are swallowed so one bad
+ *  account never aborts the run. */
+export declare function runReconcile(deps: ReconcileDeps): void;
+export interface AccountDirSchemaReconcile {
+    start(): void;
+    stop(): void;
+}
+/** Standing periodic reconcile. Unref'd interval so it never holds the process
+ *  open; each tick re-runs the pass best-effort. */
+export declare function createAccountDirSchemaReconcile(deps: ReconcileDeps & {
+    intervalMs: number;
+}): AccountDirSchemaReconcile;
+//# sourceMappingURL=account-dir-schema-reconcile.d.ts.map

package/payload/platform/services/claude-session-manager/dist/account-dir-schema-reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account-dir-schema-reconcile.d.ts","sourceRoot":"","sources":["../src/account-dir-schema-reconcile.ts"],"names":[],"mappings":"AA2FA,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,CAAA;IACrB,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;+DAE+D;AAC/D,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,eAAe,GAAG,MAAM,CAE9D;AAED;;8EAE8E;AAC9E,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAcpE;AA0FD;;;gFAGgF;AAChF,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,GAAG,eAAe,CAwDvF;AAED,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAC9B,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CACnB;AAED;;;oCAGoC;AACpC,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,CAwBtD;AAED,MAAM,WAAW,yBAAyB;IACxC,KAAK,IAAI,IAAI,CAAA;IACb,IAAI,IAAI,IAAI,CAAA;CACb;AAED;oDACoD;AACpD,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,aAAa,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GAC3C,yBAAyB,CAiB3B"}