frappe-builder 1.1.0-dev.12 → 1.1.0-dev.16

package/extensions/frappe-workflow.ts

@@ -1,26 +1,43 @@
 import { getCurrentPhase, db } from "../state/db.js";
 import { isToolAllowedInPhase, getValidPhase, type Phase } from "../state/fsm.js";
 import { appendEntry } from "../state/journal.js";
+import { loadConfig } from "../config/loader.js";
+import { type PermissionMode, DEFAULT_PERMISSION_MODE } from "../config/defaults.js";
+
+// Re-export for use in tests and other modules
+export type { PermissionMode };
+
+/**
+ * Tools that mutate files, run shell commands, or write state.
+ * These are subject to default-mode confirmation and plan-mode blocking.
+ */
+export const WRITE_TOOLS = new Set([
+  "Write", "Edit", "NotebookEdit",
+  "Bash",
+  "scaffold_doctype", "bench_execute",
+  "create_component", "complete_component",
+]);
 
 interface BlockedResponse {
   blocked: true;
   tool: string;
   current_phase: Phase;
-  valid_phase: Phase | "any";
+  valid_phase: string;
   message: string;
 }
 
 function buildBlockedResponse(
   tool: string,
   currentPhase: Phase,
-  validPhase: Phase | "any"
+  validPhase: Phase | Phase[] | "any"
 ): BlockedResponse {
+  const validLabel = Array.isArray(validPhase) ? validPhase.join(", ") : validPhase;
   return {
     blocked: true,
     tool,
     current_phase: currentPhase,
-    valid_phase: validPhase,
-    message: `${tool} is not available in ${currentPhase} phase. Available in: ${validPhase}`,
+    valid_phase: validLabel,
+    message: `${tool} is not available in ${currentPhase} phase. Available in: ${validLabel}`,
   };
 }
 
@@ -34,7 +51,7 @@ function buildBlockedResponse(
  * Never throws — always returns a value or undefined.
  */
 // Tools valid in all phases — never blocked by the phase guard (FR34)
-const ALWAYS_ALLOWED_TOOLS = ["invoke_debugger", "end_debug", "spawn_agent", "get_frappe_docs", "get_audit_log"];
+const ALWAYS_ALLOWED_TOOLS = ["invoke_debugger", "end_debug", "spawn_agent", "get_frappe_docs", "get_audit_log", "get_project_status"];
 
 export function beforeToolCall(
   toolName: string,
@@ -73,13 +90,75 @@ export function beforeToolCall(
   return undefined; // allow
 }
 
+/**
+ * Checks the active permission mode for write tools.
+ * - auto: always allowed
+ * - plan: always blocked with dry-run message
+ * - default: prompts via ctx.ui.input(); falls through if unavailable
+ *
+ * Returns a blocked response to halt execution, or undefined to allow.
+ * Never throws.
+ */
+export async function checkPermissionMode(
+  toolName: string,
+  mode: PermissionMode,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ctx?: any,
+): Promise<BlockedResponse | undefined> {
+  if (!WRITE_TOOLS.has(toolName)) return undefined;
+  if (mode === "auto") return undefined;
+
+  if (mode === "plan") {
+    return {
+      blocked: true,
+      tool: toolName,
+      current_phase: getCurrentPhase() as Phase,
+      valid_phase: "any",
+      message: `[plan mode] ${toolName} is a write operation — dry-run only. Switch to default or auto mode to execute.`,
+    };
+  }
+
+  // default mode: prompt via ctx.ui.input()
+  if (ctx) {
+    try {
+      const answer: string = await ctx.ui.input(`Allow ${toolName}? (yes/no)`);
+      if (!["yes", "y"].includes(answer?.toLowerCase?.() ?? "")) {
+        return {
+          blocked: true,
+          tool: toolName,
+          current_phase: getCurrentPhase() as Phase,
+          valid_phase: "any",
+          message: `${toolName} blocked by user.`,
+        };
+      }
+    } catch {
+      // ctx.ui.input unavailable — fail open (allow)
+    }
+  }
+
+  return undefined;
+}
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export default function (pi: any) {
-  pi.on("tool_call", (event: { toolName?: string; input?: Record<string, unknown> }) => {
-    const result = beforeToolCall(event.toolName ?? "", event.input ?? {});
-    if (result) {
-      return { block: true, reason: result.message };
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  pi.on("tool_call", async (event: { toolName?: string; input?: Record<string, unknown> }, ctx: any) => {
+    const toolName = event.toolName ?? "";
+
+    // Phase guard
+    const phaseResult = beforeToolCall(toolName, event.input ?? {});
+    if (phaseResult) {
+      return { block: true, reason: phaseResult.message };
     }
+
+    // Permission mode guard (Story 9.2–9.4)
+    const config = loadConfig();
+    const mode: PermissionMode = config.permissionMode ?? DEFAULT_PERMISSION_MODE;
+    const permResult = await checkPermissionMode(toolName, mode, ctx);
+    if (permResult) {
+      return { block: true, reason: permResult.message };
+    }
+
     return undefined;
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "frappe-builder",
-  "version": "1.1.0-dev.12",
+  "version": "1.1.0-dev.16",
   "description": "Frappe-native AI co-pilot for building and customising Frappe/ERPNext applications",
   "type": "module",
   "bin": {

package/state/artifacts.ts

@@ -0,0 +1,85 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { db } from "./db.js";
+
+/**
+ * Returns the artifact directory for a feature.
+ * When app_path is set: {app_path}/.frappe-builder/{featureId}/
+ * Fallback (no app_path): {cwd}/.frappe-builder/{featureId}/
+ */
+export function getArtifactDir(featureId: string): string {
+  const row = db
+    .prepare("SELECT app_path FROM sessions WHERE is_active = 1 LIMIT 1")
+    .get() as { app_path: string | null } | undefined;
+  const root = row?.app_path ?? process.cwd();
+  return join(root, ".frappe-builder", featureId);
+}
+
+/**
+ * Regenerates sprint-status.yaml for the given feature from current DB state.
+ * Called after every create_component and complete_component.
+ * Creates the artifact directory if it does not exist.
+ * Non-fatal — caller should catch any errors.
+ */
+export function regenerateSprintStatus(featureId: string): void {
+  const feature = db
+    .prepare("SELECT feature_id, name, mode, current_phase FROM features WHERE feature_id = ?")
+    .get(featureId) as
+    | { feature_id: string; name: string; mode: string; current_phase: string }
+    | undefined;
+
+  if (!feature) return;
+
+  const components = db
+    .prepare(
+      `SELECT component_id, description, sort_order, status, completed_at
+       FROM components WHERE feature_id = ?
+       ORDER BY sort_order ASC, component_id ASC`
+    )
+    .all(featureId) as Array<{
+      component_id: string;
+      description: string | null;
+      sort_order: number;
+      status: string;
+      completed_at: string | null;
+    }>;
+
+  const done = components.filter((c) => c.status === "complete").length;
+  const total = components.length;
+
+  const componentLines = components
+    .map((c) => {
+      const descLine = c.description
+        ? `    description: "${c.description.replace(/"/g, '\\"')}"`
+        : "";
+      return [
+        `  - id: ${c.component_id}`,
+        descLine,
+        `    sort_order: ${c.sort_order}`,
+        `    status: ${c.status}`,
+        `    completed_at: ${c.completed_at ?? "null"}`,
+      ]
+        .filter(Boolean)
+        .join("\n");
+    })
+    .join("\n");
+
+  const yaml = `feature_id: ${feature.feature_id}
+feature_name: "${feature.name.replace(/"/g, '\\"')}"
+mode: ${feature.mode}
+phase: ${feature.current_phase}
+updated_at: ${new Date().toISOString()}
+
+components:
+${componentLines || "  []"}
+
+progress:
+  done: ${done}
+  total: ${total}
+`;
+
+  const artifactDir = getArtifactDir(featureId);
+  const implDir = join(artifactDir, "implementation-artifacts");
+  mkdirSync(implDir, { recursive: true });
+  writeFileSync(join(implDir, "sprint-status.yaml"), yaml, "utf-8");
+}

package/state/db.ts

@@ -1,7 +1,7 @@
 import Database from "better-sqlite3";
 import type { Database as DatabaseType } from "better-sqlite3";
 import { mkdirSync } from "node:fs";
-import { initSchema } from "./schema.js";
+import { initSchema, migrateSchema } from "./schema.js";
 import { appendEntry } from "./journal.js";
 
 mkdirSync(".fb", { recursive: true });
@@ -10,6 +10,7 @@ mkdirSync(".fb", { recursive: true });
 export let db: DatabaseType = new Database(".fb/state.db");
 
 initSchema(db);
+migrateSchema(db);
 
 /**
  * Replaces the db singleton — intended for test use only.
@@ -24,9 +25,9 @@ export function setDb(instance: DatabaseType): void {
  * a new session for newProjectId, restoring its last known phase if a prior
  * session exists. Writes a "state_transition" JSONL entry before the close.
  *
- * sitePath is optional so existing callers without a site path continue to work.
+ * sitePath and appPath are optional so existing callers without them continue to work.
  */
-export function switchProject(newProjectId: string, sitePath?: string): void {
+export function switchProject(newProjectId: string, sitePath?: string, appPath?: string): void {
   db.transaction(() => {
     // 1. Read current active session before closing
     const current = db
@@ -62,12 +63,13 @@ export function switchProject(newProjectId: string, sitePath?: string): void {
 
     // 5. Create new session, restoring prior phase if available; feature_id defaults to NULL
     db.prepare(
-      "INSERT INTO sessions (session_id, project_id, current_phase, site_path, started_at, is_active) VALUES (?, ?, ?, ?, ?, 1)"
+      "INSERT INTO sessions (session_id, project_id, current_phase, site_path, app_path, started_at, is_active) VALUES (?, ?, ?, ?, ?, ?, 1)"
     ).run(
       crypto.randomUUID(),
       newProjectId,
       prior?.current_phase ?? "idle",
       sitePath ?? null,
+      appPath ?? null,
       new Date().toISOString()
     );
   })();

package/state/fsm.ts

@@ -7,7 +7,8 @@ export type Phase =
   | "planning"
   | "implementation"
   | "testing"
-  | "documentation";
+  | "documentation"
+  | "chain_running";  // sentinel: full-mode chain active externally, not an in-session FSM node
 
 export const ALL_PHASES: Phase[] = [
   "idle",
@@ -17,52 +18,74 @@ export const ALL_PHASES: Phase[] = [
   "implementation",
   "testing",
   "documentation",
+  "chain_running",
 ];
 
 function buildMachineStates() {
   return {
+    // Quick mode only: idle → implementation.
+    // Full mode phases (requirements, architecture, planning, testing, documentation)
+    // are handled by agent-chain.ts subprocesses — not in-session FSM transitions.
     idle: state(
-      transition("start_full", "requirements"),
-      transition("start_quick", "implementation") as never // quick mode bypass (Story 3.3)
+      transition("start_quick", "implementation")
     ),
-    requirements: state(transition("approve", "architecture")),
-    architecture: state(transition("approve", "planning")),
-    planning: state(transition("approve", "implementation")),
     implementation: state(transition("approve", "testing")),
     testing: state(transition("approve", "documentation")),
     documentation: state(transition("complete", "idle")),
+    // chain_running is a storage sentinel — not a FSM node with transitions.
+    // The parent session cannot transition out of chain_running via FSM events;
+    // the chain runner updates the DB directly when the chain completes.
   };
 }
 
-/** Creates a Robot3 FSM starting at the given phase — fast-forward, no event replay. */
+type FsmPhase = "idle" | "implementation" | "testing" | "documentation";
+const FSM_PHASES = new Set<string>(["idle", "implementation", "testing", "documentation"]);
+
+/** Creates a Robot3 FSM starting at the given phase — fast-forward, no event replay.
+ *  Non-FSM phases (chain_running, requirements, architecture, planning) fall back to idle. */
 export function createFsmAtPhase(phase: Phase) {
-  return createMachine(phase, buildMachineStates());
+  const fsmPhase: FsmPhase = FSM_PHASES.has(phase) ? (phase as FsmPhase) : "idle";
+  return createMachine(fsmPhase, buildMachineStates());
 }
 
 /**
  * Maps each tool to its valid phase (or 'any').
  * Tools not listed here are allowed in any phase — do not block unregistered tools.
  */
-const TOOL_PHASE_MAP: Record<string, Phase | "any"> = {
+const TOOL_PHASE_MAP: Record<string, Phase | Phase[] | "any"> = {
   set_active_project: "any",
-  start_feature: "idle",
+  start_feature: "idle",          // blocked in chain_running to prevent double-start
+  create_component: ["planning", "implementation"],
   complete_component: "implementation",
   scaffold_doctype: "implementation",
   run_tests: "testing",
   get_project_status: "any",
   frappe_query: "any",
-  bench_execute: "any",   // allowed in all phases — includes testing (bench run-tests) and implementation (bench migrate)
+  bench_execute: "any",
 };
 
+/** Always-allowed tools that bypass phase guard entirely. */
+const ALWAYS_ALLOWED_TOOLS = new Set([
+  "invoke_debugger",
+  "end_debug",
+  "spawn_agent",
+  "get_project_status",
+  "get_frappe_docs",
+]);
+
 /** Returns true if toolName is allowed to run in the given phase. Unknown tools are always allowed. */
 export function isToolAllowedInPhase(toolName: string, phase: Phase): boolean {
+  if (ALWAYS_ALLOWED_TOOLS.has(toolName)) return true;
+  // chain_running: only always-allowed tools pass; all others (including start_feature) are blocked
+  if (phase === "chain_running") return false;
   const validPhase = TOOL_PHASE_MAP[toolName];
   if (validPhase === undefined) return true; // unknown tool — do not block
   if (validPhase === "any") return true;
+  if (Array.isArray(validPhase)) return validPhase.includes(phase);
   return validPhase === phase;
 }
 
 /** Returns the phase where toolName is valid, or 'any' for unrestricted/unknown tools. */
-export function getValidPhase(toolName: string): Phase | "any" {
+export function getValidPhase(toolName: string): Phase | Phase[] | "any" {
   return TOOL_PHASE_MAP[toolName] ?? "any";
 }

package/state/schema.ts

@@ -18,9 +18,13 @@ export function initSchema(db: Database): void {
     );
 
     CREATE TABLE IF NOT EXISTS components (
-      component_id TEXT NOT NULL,
-      feature_id   TEXT NOT NULL,
-      status       TEXT NOT NULL DEFAULT 'in-progress',
+      component_id TEXT    NOT NULL,
+      feature_id   TEXT    NOT NULL,
+      status       TEXT    NOT NULL DEFAULT 'in-progress'
+        CHECK (status IN ('in-progress', 'complete')),
+      description  TEXT,
+      sort_order   INTEGER NOT NULL DEFAULT 0,
+      created_at   TEXT,
       completed_at TEXT,
       PRIMARY KEY (feature_id, component_id),
       FOREIGN KEY (feature_id) REFERENCES features(feature_id)
@@ -31,7 +35,11 @@ export function initSchema(db: Database): void {
       project_id    TEXT NOT NULL,
       current_phase TEXT NOT NULL DEFAULT 'idle',
       site_path     TEXT,
+      app_path      TEXT,
+      chain_step    TEXT,
+      chain_pid     INTEGER,
       feature_id    TEXT,
+      component_id  TEXT,
       last_tool     TEXT,
       started_at    TEXT NOT NULL,
       ended_at      TEXT,
@@ -39,3 +47,23 @@ export function initSchema(db: Database): void {
     );
   `);
 }
+
+/**
+ * Adds new columns to existing databases without dropping data.
+ * Safe to call on any DB version — ignores "duplicate column" errors.
+ * Call this after initSchema() in db.ts.
+ */
+export function migrateSchema(db: Database): void {
+  const alters = [
+    "ALTER TABLE components ADD COLUMN description TEXT",
+    "ALTER TABLE components ADD COLUMN sort_order INTEGER NOT NULL DEFAULT 0",
+    "ALTER TABLE components ADD COLUMN created_at TEXT",
+    "ALTER TABLE sessions ADD COLUMN component_id TEXT",
+    "ALTER TABLE sessions ADD COLUMN app_path TEXT",
+    "ALTER TABLE sessions ADD COLUMN chain_step TEXT",
+    "ALTER TABLE sessions ADD COLUMN chain_pid INTEGER",
+  ];
+  for (const sql of alters) {
+    try { db.exec(sql); } catch { /* column already exists — safe to ignore */ }
+  }
+}

package/tools/feature-tools.ts

@@ -3,6 +3,8 @@ import { db } from "../state/db.js";
 import { appendEntry } from "../state/journal.js";
 import { loadConfig } from "../config/loader.js";
 import { coverageCheck } from "../gates/coverage-check.js";
+import { getArtifactDir, regenerateSprintStatus } from "../state/artifacts.js";
+import { spawnChain } from "../extensions/agent-chain.js";
 
 interface StartFeatureArgs {
   name: string;
@@ -14,11 +16,18 @@ function toFeatureId(name: string): string {
 }
 
 /**
- * Creates a new feature row in state.db and writes a state_transition JSONL entry.
- * Returns the feature data directly — no wrapper object.
- * mode defaults to "full" — feature row always stores an explicit mode value.
+ * Creates a new feature row in state.db, applies the FSM phase transition,
+ * and links the feature to the active session.
+ *
+ * Phase transition is applied inside the tool (not deferred to afterToolCall) so
+ * the returned JSON reflects the actual post-transition phase. The agent reads
+ * this value directly — returning "idle" caused session confusion.
+ *
+ * quick mode → implementation immediately (in-session).
+ * full mode → chain_running (agent chain spawned as background process).
+ * Default mode is "quick".
  */
-export function startFeature({ name, mode = "full" }: StartFeatureArgs) {
+export async function startFeature({ name, mode = "quick" }: StartFeatureArgs) {
   const featureId = toFeatureId(name);
   const createdAt = new Date().toISOString();
 
@@ -26,18 +35,122 @@ export function startFeature({ name, mode = "full" }: StartFeatureArgs) {
     .prepare("SELECT session_id FROM sessions WHERE is_active = 1 LIMIT 1")
     .get() as { session_id: string } | undefined;
 
+  if (mode === "quick") {
+    const newPhase = "implementation";
+    db.prepare(
+      "INSERT INTO features (feature_id, name, created_at, mode, current_phase) VALUES (?, ?, ?, ?, ?)"
+    ).run(featureId, name, createdAt, mode, newPhase);
+
+    db.transaction(() => {
+      db.prepare(
+        "UPDATE sessions SET feature_id = ?, current_phase = ? WHERE is_active = 1"
+      ).run(featureId, newPhase);
+    })();
+
+    appendEntry({
+      ts: createdAt,
+      sessionId: session?.session_id ?? "unknown",
+      type: "state_transition",
+      payload: { from: "idle", to: newPhase, feature: name, mode },
+    });
+
+    return { feature_id: featureId, name, mode, current_phase: newPhase, created_at: createdAt };
+  }
+
+  // Full mode: insert feature at "requirements", set session to chain_running, fire chain
   db.prepare(
-    "INSERT INTO features (feature_id, name, created_at, mode, current_phase) VALUES (?, ?, ?, ?, 'idle')"
-  ).run(featureId, name, createdAt, mode);
+    "INSERT INTO features (feature_id, name, created_at, mode, current_phase) VALUES (?, ?, ?, ?, ?)"
+  ).run(featureId, name, createdAt, mode, "requirements");
+
+  db.transaction(() => {
+    db.prepare(
+      "UPDATE sessions SET feature_id = ?, current_phase = ? WHERE is_active = 1"
+    ).run(featureId, "chain_running");
+  })();
+
+  appendEntry({
+    ts: createdAt,
+    sessionId: session?.session_id ?? "unknown",
+    type: "state_transition",
+    payload: { from: "idle", to: "chain_running", feature: name, mode },
+  });
+
+  const artifactDir = getArtifactDir(featureId);
+
+  // Fire-and-forget: chain runs independently in the background
+  setImmediate(() => {
+    Promise.resolve(spawnChain(featureId, name, artifactDir)).catch((err: unknown) => {
+      console.error(`[agent-chain] chain failed for ${featureId}: ${err}`);
+    });
+  });
+
+  return { feature_id: featureId, name, mode, current_phase: "chain_running", chain_started: true, created_at: createdAt };
+}
+
+interface CreateComponentArgs {
+  featureId: string;
+  componentId: string;
+  description?: string;
+  sortOrder?: number;
+}
+
+/**
+ * Explicitly creates a component for a feature with status 'in-progress'.
+ * Sets this component as the active component on the session (for footer display).
+ * Regenerates sprint-status.yaml in .frappe-builder-artifacts/{featureId}/.
+ *
+ * Call this during the planning phase (full mode) or at the start of implementation
+ * (quick mode) — before work begins, not at completion time.
+ */
+export function createComponent({ featureId, componentId, description, sortOrder = 0 }: CreateComponentArgs) {
+  const createdAt = new Date().toISOString();
+
+  const feature = db
+    .prepare("SELECT feature_id FROM features WHERE feature_id = ?")
+    .get(featureId) as { feature_id: string } | undefined;
+
+  if (!feature) {
+    return { error: `Feature '${featureId}' not found. Call start_feature first.` };
+  }
+
+  const session = db
+    .prepare("SELECT session_id FROM sessions WHERE is_active = 1 LIMIT 1")
+    .get() as { session_id: string } | undefined;
+
+  const existing = db
+    .prepare("SELECT component_id FROM components WHERE feature_id = ? AND component_id = ?")
+    .get(featureId, componentId) as { component_id: string } | undefined;
+
+  db.prepare(`
+    INSERT INTO components (feature_id, component_id, status, description, sort_order, created_at)
+    VALUES (?, ?, 'in-progress', ?, ?, ?)
+    ON CONFLICT(feature_id, component_id)
+    DO UPDATE SET description = excluded.description, sort_order = excluded.sort_order
+  `).run(featureId, componentId, description ?? null, sortOrder, createdAt);
+
+  if (!existing) {
+    db.prepare("UPDATE features SET progress_total = progress_total + 1 WHERE feature_id = ?")
+      .run(featureId);
+  }
+
+  db.prepare("UPDATE sessions SET component_id = ? WHERE is_active = 1")
+    .run(componentId);
+
+  regenerateSprintStatus(featureId);
 
   appendEntry({
     ts: createdAt,
     sessionId: session?.session_id ?? "unknown",
     type: "state_transition",
-    payload: { from: "idle", to: "feature_started", feature: name },
+    payload: { feature: featureId, component: componentId, action: "create_component", status: "in-progress" },
   });
 
-  return { feature_id: featureId, name, mode, current_phase: "idle", created_at: createdAt };
+  return {
+    feature_id: featureId,
+    component_id: componentId,
+    status: "in-progress",
+    artifact_dir: getArtifactDir(featureId),
+  };
 }
 
 interface CompleteComponentArgs {
@@ -105,6 +218,10 @@ export async function completeComponent({ featureId, componentId }: CompleteComp
     DO UPDATE SET status = 'complete', completed_at = excluded.completed_at
   `).run(featureId, componentId, completedAt);
 
+  db.prepare("UPDATE sessions SET component_id = NULL WHERE is_active = 1").run();
+  db.prepare("UPDATE features SET progress_done = progress_done + 1 WHERE feature_id = ?").run(featureId);
+  regenerateSprintStatus(featureId);
+
   appendEntry({
     ts: completedAt,
     sessionId,

package/tools/project-tools.ts

@@ -77,6 +77,7 @@ export function getProjectStatus(_args?: unknown): ProjectStatus {
 interface SetActiveProjectArgs {
   projectId: string;
   sitePath: string;
+  appPath?: string;
 }
 
 /**
@@ -86,9 +87,9 @@ interface SetActiveProjectArgs {
  * The state_transition JSONL entry is written inside switchProject() —
  * no second appendEntry() call here.
  */
-export async function setActiveProject({ projectId, sitePath }: SetActiveProjectArgs) {
+export async function setActiveProject({ projectId, sitePath, appPath }: SetActiveProjectArgs) {
   // Flush current state + create new session (JSONL entry written internally)
-  switchProject(projectId, sitePath);
+  switchProject(projectId, sitePath, appPath);
 
   // Reload system prompt with new project context
   await reloadSessionContext();
@@ -101,6 +102,7 @@ export async function setActiveProject({ projectId, sitePath }: SetActiveProject
   return {
     project_id: projectId,
     site_path: sitePath,
+    app_path: appPath ?? null,
     phase: session?.current_phase ?? "idle",
     context_reloaded: true,
   };