graphai 2.0.16 → 2.0.17

package/README.md

@@ -24,7 +24,7 @@ nodes:
       query: describe the final sentence by the court for Sam Bank-Fried
   wikipedia:
     console:
-      before: ...fetching data from wikkpedia
+      before: ...fetching data from wikipedia
     agent: wikipediaAgent
     inputs:
       query: :source.name

package/lib/graphai.js

@@ -123,9 +123,13 @@ class GraphAI {
         this.graphId = `${Date.now().toString(36)}-${Math.random().toString(36).substr(2, 9)}`; // URL.createObjectURL(new Blob()).slice(-36);
         this.agentFunctionInfoDictionary = agentFunctionInfoDictionary;
         this.propFunctions = prop_function_1.propFunctions;
+        this.bypassAgentIds = options.bypassAgentIds ?? [];
+        // Validate before constructing TaskManager so user-facing ValidationError
+        // is reported instead of TaskManager's internal guard message.
+        (0, validator_1.validateGraphData)(graphData, [...Object.keys(agentFunctionInfoDictionary), ...this.bypassAgentIds]);
+        (0, validator_1.validateAgent)(agentFunctionInfoDictionary);
         this.taskManager = options.taskManager ?? new task_manager_1.TaskManager(graphData.concurrency ?? exports.defaultConcurrency);
         this.agentFilters = options.agentFilters ?? [];
-        this.bypassAgentIds = options.bypassAgentIds ?? [];
         this.config = options.config;
         this.graphLoader = options.graphLoader;
         this.forceLoop = options.forceLoop ?? false;
@@ -135,8 +139,6 @@ class GraphAI {
         this.onComplete = (__isAbort) => {
             throw new Error("SOMETHING IS WRONG: onComplete is called without run()");
         };
-        (0, validator_1.validateGraphData)(graphData, [...Object.keys(agentFunctionInfoDictionary), ...this.bypassAgentIds]);
-        (0, validator_1.validateAgent)(agentFunctionInfoDictionary);
         this.graphData = {
             ...graphData,
             nodes: {

package/lib/node.d.ts

@@ -27,6 +27,7 @@ export declare class ComputedNode extends Node {
     private agentFunction?;
     readonly timeout?: number;
     readonly priority: number;
+    readonly label?: string;
     error?: Error;
     transactionId: undefined | number;
     private readonly passThrough?;

package/lib/node.js

@@ -67,6 +67,7 @@ class ComputedNode extends Node {
     agentFunction;
     timeout; // msec
     priority;
+    label;
     error;
     transactionId; // To reject callbacks from timed-out transactions
     passThrough;
@@ -94,6 +95,10 @@ class ComputedNode extends Node {
         this.timeout = data.timeout;
         this.isResult = data.isResult ?? false;
         this.priority = data.priority ?? 0;
+        // Defensive: graph data may originate from YAML/JSON without strict typing.
+        // Keep label only when it is actually a string so TaskManager's label-keyed
+        // bookkeeping cannot be silently bypassed by a non-string value.
+        this.label = typeof data.label === "string" ? data.label : undefined;
         (0, utils_2.assert)(["function", "string"].includes(typeof data.agent), "agent must be either string or function");
         if (typeof data.agent === "string") {
             this.agentId = data.agent;
@@ -293,50 +298,61 @@ class ComputedNode extends Node {
             const agentFunction = this.agentFunction ?? this.graph.getAgentFunctionInfo(agentId, this.nodeId).agent;
             const localLog = [];
             const context = this.getContext(previousResults, localLog, agentId, config);
-            // NOTE: We use the existence of graph object in the agent-specific params to determine
-            // if this is a nested agent or not.
-            if (hasNestedGraph) {
-                this.graph.taskManager.prepareForNesting();
-                context.forNestedGraph = {
-                    graphData: this.nestedGraph
-                        ? "nodes" in this.nestedGraph
-                            ? this.nestedGraph
-                            : this.graph.resultOf(this.nestedGraph) // HACK: compiler work-around
-                        : { version: 0, nodes: {} },
-                    agents: this.graph.agentFunctionInfoDictionary,
-                    graphOptions: {
-                        agentFilters: this.graph.agentFilters,
-                        taskManager: this.graph.taskManager,
-                        bypassAgentIds: this.graph.bypassAgentIds,
-                        config,
-                        graphLoader: this.graph.graphLoader,
-                    },
-                    onLogCallback: this.graph.onLogCallback,
-                    callbacks: this.graph.callbacks,
-                };
-            }
-            this.beforeConsoleLog(context);
-            const result = await this.agentFilterHandler(context, agentFunction, agentId);
-            this.afterConsoleLog(result);
-            if (hasNestedGraph) {
-                this.graph.taskManager.restoreAfterNesting();
-            }
-            if (!this.isCurrentTransaction(transactionId)) {
-                // This condition happens when the agent function returns
-                // after the timeout (either retried or not).
-                GraphAILogger_1.GraphAILogger.log(`-- transactionId mismatch with ${this.nodeId} (probably timeout)`);
-                return;
-            }
-            if (this.repeatUntil?.exists) {
-                const dummyResult = { self: { result: this.getResult(result) } };
-                const repeatResult = (0, result_1.resultsOf)({ data: this.repeatUntil?.exists }, dummyResult, [], true);
-                if ((0, utils_1.isNull)(repeatResult?.data)) {
-                    this.retry(type_1.NodeState.Failed, Error("Repeat Until"));
+            // The `nestingPrepared` flag tracks whether prepareForNesting has actually
+            // run. If anything throws between prepareForNesting and the agent call --
+            // e.g. resultOf() during forNestedGraph construction -- we still need to
+            // restore. Conversely, if prepareForNesting itself throws, we must NOT
+            // restore (no bump to undo).
+            let nestingPrepared = false;
+            try {
+                // NOTE: We use the existence of graph object in the agent-specific params to determine
+                // if this is a nested agent or not.
+                if (hasNestedGraph) {
+                    this.graph.taskManager.prepareForNesting(this.label, this.graphId);
+                    nestingPrepared = true;
+                    context.forNestedGraph = {
+                        graphData: this.nestedGraph
+                            ? "nodes" in this.nestedGraph
+                                ? this.nestedGraph
+                                : this.graph.resultOf(this.nestedGraph) // HACK: compiler work-around
+                            : { version: 0, nodes: {} },
+                        agents: this.graph.agentFunctionInfoDictionary,
+                        graphOptions: {
+                            agentFilters: this.graph.agentFilters,
+                            taskManager: this.graph.taskManager,
+                            bypassAgentIds: this.graph.bypassAgentIds,
+                            config,
+                            graphLoader: this.graph.graphLoader,
+                        },
+                        onLogCallback: this.graph.onLogCallback,
+                        callbacks: this.graph.callbacks,
+                    };
+                }
+                this.beforeConsoleLog(context);
+                const result = await this.agentFilterHandler(context, agentFunction, agentId);
+                this.afterConsoleLog(result);
+                if (!this.isCurrentTransaction(transactionId)) {
+                    // This condition happens when the agent function returns
+                    // after the timeout (either retried or not).
+                    GraphAILogger_1.GraphAILogger.log(`-- transactionId mismatch with ${this.nodeId} (probably timeout)`);
                     return;
                 }
+                if (this.repeatUntil?.exists) {
+                    const dummyResult = { self: { result: this.getResult(result) } };
+                    const repeatResult = (0, result_1.resultsOf)({ data: this.repeatUntil?.exists }, dummyResult, [], true);
+                    if ((0, utils_1.isNull)(repeatResult?.data)) {
+                        this.retry(type_1.NodeState.Failed, Error("Repeat Until"));
+                        return;
+                    }
+                }
+                // after process
+                this.afterExecute(result, localLog);
+            }
+            finally {
+                if (nestingPrepared) {
+                    this.graph.taskManager.restoreAfterNesting(this.label, this.graphId);
+                }
             }
-            // after process
-            this.afterExecute(result, localLog);
         }
         catch (error) {
             this.errorProcess(error, transactionId, previousResults);

package/lib/task_manager.d.ts

@@ -1,15 +1,20 @@
 import { ComputedNode } from "./node";
+import { ConcurrencyConfig } from "./type";
 export declare class TaskManager {
     private concurrency;
+    private labelLimits;
+    private runningByLabel;
+    private nestingBypassByLabel;
     private taskQueue;
     private runningNodes;
-    constructor(concurrency: number);
+    constructor(config: number | ConcurrencyConfig);
+    private canRun;
     private dequeueTaskIfPossible;
     addTask(node: ComputedNode, graphId: string, callback: (node: ComputedNode) => void): void;
     isRunning(graphId: string): boolean;
     onComplete(node: ComputedNode): void;
-    prepareForNesting(): void;
-    restoreAfterNesting(): void;
+    prepareForNesting(label?: string, parentGraphId?: string): void;
+    restoreAfterNesting(label?: string, parentGraphId?: string): void;
     getStatus(verbose?: boolean): {
         runningNodes: string[];
         queuedNodes: string[];

package/lib/task_manager.js

@@ -2,33 +2,113 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskManager = void 0;
 const utils_1 = require("./utils/utils");
+const assertPositiveInteger = (value, field) => {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+        throw new Error(`TaskManager: ${field} must be a positive integer (got ${String(value)})`);
+    }
+    return value;
+};
+// Mirrors the strictness of validateConcurrencyConfig() so that direct
+// `new TaskManager(...)` calls (e.g. tests, advanced consumers that bypass
+// validateGraphData) cannot silently disable label enforcement with a
+// malformed shape such as Map / Date / class instances / arrays.
+const normalizeConcurrencyConfig = (config) => {
+    if (typeof config === "number") {
+        return { global: assertPositiveInteger(config, "concurrency"), labels: new Map() };
+    }
+    if (!(0, utils_1.isPlainObject)(config)) {
+        throw new Error("TaskManager: concurrency must be a positive integer or a ConcurrencyConfig object");
+    }
+    const global = assertPositiveInteger(config.global, "concurrency.global");
+    const labels = new Map();
+    if (config.labels !== undefined) {
+        if (!(0, utils_1.isPlainObject)(config.labels)) {
+            throw new Error("TaskManager: concurrency.labels must be a plain object");
+        }
+        for (const [labelKey, labelValue] of Object.entries(config.labels)) {
+            labels.set(labelKey, assertPositiveInteger(labelValue, `concurrency.labels.${labelKey}`));
+        }
+    }
+    return { global, labels };
+};
 // TaskManage object controls the concurrency of ComputedNode execution.
 //
 // NOTE: A TaskManager instance will be shared between parent graph and its children
 // when nested agents are involved.
 class TaskManager {
     concurrency;
+    labelLimits;
+    runningByLabel = new Map();
+    // Per-label bypass capacity granted to nested children. Keyed by parentGraphId
+    // so that only tasks whose graphId differs from the parent (i.e. those running
+    // inside the nested graph) can consume the extra slot. Unrelated siblings on
+    // the same graphId as the parent are not affected.
+    nestingBypassByLabel = new Map();
     taskQueue = [];
     runningNodes = new Set();
-    constructor(concurrency) {
-        this.concurrency = concurrency;
+    constructor(config) {
+        const normalized = normalizeConcurrencyConfig(config);
+        this.concurrency = normalized.global;
+        this.labelLimits = normalized.labels;
     }
-    // This internal method dequeus a task from the task queue
-    // and call the associated callback method, if the number of
-    // running task is lower than the spcified limit.
+    // Returns true if the task can run right now under both the global limit
+    // and (if specified) its label-specific limit.
+    canRun(task) {
+        if (this.runningNodes.size >= this.concurrency) {
+            return false;
+        }
+        const label = task.node.label;
+        if (label === undefined) {
+            return true;
+        }
+        const limit = this.labelLimits.get(label);
+        if (limit === undefined) {
+            return true;
+        }
+        const running = this.runningByLabel.get(label) ?? 0;
+        if (running < limit) {
+            return true;
+        }
+        // Bypass path: if a labeled parent has prepared for nesting and this task
+        // belongs to a different graph (i.e. the nested graph), grant +1 per such
+        // outstanding bump. Unrelated siblings on the parent's graphId do NOT get
+        // this allowance, so the per-label cap is preserved for them.
+        const bypass = this.nestingBypassByLabel.get(label);
+        if (!bypass) {
+            return false;
+        }
+        let extra = 0;
+        for (const [parentGraphId, count] of bypass) {
+            if (parentGraphId !== task.graphId) {
+                extra += count;
+            }
+        }
+        return running < limit + extra;
+    }
+    // Walk the queue (already sorted by priority desc) and dispatch the first task
+    // whose label still has capacity. This is the "head-of-line skip" policy.
     dequeueTaskIfPossible() {
-        if (this.runningNodes.size < this.concurrency) {
-            const task = this.taskQueue.shift();
-            if (task) {
+        if (this.runningNodes.size >= this.concurrency) {
+            return;
+        }
+        for (let i = 0; i < this.taskQueue.length; i++) {
+            const task = this.taskQueue[i];
+            if (this.canRun(task)) {
+                this.taskQueue.splice(i, 1);
                 this.runningNodes.add(task.node);
+                const label = task.node.label;
+                if (label !== undefined) {
+                    this.runningByLabel.set(label, (this.runningByLabel.get(label) ?? 0) + 1);
+                }
                 task.callback(task.node);
+                return;
             }
         }
     }
     // Node will call this method to put itself in the execution queue.
     // We call the associated callback function when it is dequeued.
     addTask(node, graphId, callback) {
-        // Finder tasks in the queue, which has either the same or higher priority.
+        // Find tasks in the queue, which has either the same or higher priority.
         const count = this.taskQueue.filter((task) => {
             return task.node.priority >= node.priority;
         }).length;
@@ -47,16 +127,72 @@ class TaskManager {
     onComplete(node) {
         (0, utils_1.assert)(this.runningNodes.has(node), `TaskManager.onComplete node(${node.nodeId}) is not in list`);
         this.runningNodes.delete(node);
-        this.dequeueTaskIfPossible();
+        const label = node.label;
+        if (label !== undefined) {
+            const running = this.runningByLabel.get(label) ?? 0;
+            if (running <= 1) {
+                this.runningByLabel.delete(label);
+            }
+            else {
+                this.runningByLabel.set(label, running - 1);
+            }
+        }
+        // A label slot may have just opened, so try to dispatch as many newly-eligible
+        // tasks as possible (the freed label could allow several queued tasks to run if
+        // the global limit is not yet reached).
+        let progressed = true;
+        while (progressed) {
+            const before = this.runningNodes.size;
+            this.dequeueTaskIfPossible();
+            progressed = this.runningNodes.size > before;
+        }
     }
     // Node will call this method before it hands the task manager from the graph
     // to a nested agent. We need to make it sure that there is enough room to run
     // computed nodes inside the nested graph to avoid a deadlock.
-    prepareForNesting() {
+    //
+    // When the parent carries a label that has a configured per-label limit,
+    // a nested child sharing that label would otherwise stay queued forever
+    // (parent waits for child, child blocked by parent's label slot). To avoid
+    // this without widening the cap for unrelated siblings, we record a per-
+    // parent-graphId bypass that canRun() applies only to tasks whose graphId
+    // differs from the parent's.
+    prepareForNesting(label, parentGraphId) {
         this.concurrency++;
+        if (label !== undefined && parentGraphId !== undefined && this.labelLimits.has(label)) {
+            let perParent = this.nestingBypassByLabel.get(label);
+            if (!perParent) {
+                perParent = new Map();
+                this.nestingBypassByLabel.set(label, perParent);
+            }
+            perParent.set(parentGraphId, (perParent.get(parentGraphId) ?? 0) + 1);
+        }
+        // Both the global slot bump and the optional label bypass can free capacity
+        // for already-queued tasks; drain the queue while progress is being made.
+        let progressed = true;
+        while (progressed) {
+            const before = this.runningNodes.size;
+            this.dequeueTaskIfPossible();
+            progressed = this.runningNodes.size > before;
+        }
     }
-    restoreAfterNesting() {
+    restoreAfterNesting(label, parentGraphId) {
         this.concurrency--;
+        if (label !== undefined && parentGraphId !== undefined) {
+            const perParent = this.nestingBypassByLabel.get(label);
+            if (perParent) {
+                const next = (perParent.get(parentGraphId) ?? 0) - 1;
+                if (next <= 0) {
+                    perParent.delete(parentGraphId);
+                }
+                else {
+                    perParent.set(parentGraphId, next);
+                }
+                if (perParent.size === 0) {
+                    this.nestingBypassByLabel.delete(label);
+                }
+            }
+        }
     }
     getStatus(verbose = false) {
         const runningNodes = Array.from(this.runningNodes).map((node) => node.nodeId);
@@ -72,6 +208,8 @@ class TaskManager {
     reset() {
         this.taskQueue.length = 0;
         this.runningNodes.clear();
+        this.runningByLabel.clear();
+        this.nestingBypassByLabel.clear();
     }
 }
 exports.TaskManager = TaskManager;

package/lib/type.d.ts

@@ -65,6 +65,7 @@ export type ComputedNodeData = {
     graphLoader?: GraphDataLoaderOption;
     isResult?: boolean;
     priority?: number;
+    label?: string;
     passThrough?: PassThrough;
     console?: ConsoleElement;
 };
@@ -73,10 +74,14 @@ export type LoopData = {
     count?: number;
     while?: string | boolean;
 };
+export type ConcurrencyConfig = {
+    global: number;
+    labels?: Record<string, number>;
+};
 export type GraphData = {
     version?: number;
     nodes: Record<string, NodeData>;
-    concurrency?: number;
+    concurrency?: number | ConcurrencyConfig;
     loop?: LoopData;
     verbose?: boolean;
     retry?: number;

package/lib/utils/utils.d.ts

@@ -4,6 +4,7 @@ export declare const sleep: (milliseconds: number) => Promise<unknown>;
 export declare const parseNodeName: (inputNodeId: any, isSelfNode?: boolean, nodes?: GraphNodes) => DataSource;
 export declare function assert(condition: boolean, message: string, isWarn?: boolean, cause?: unknown): asserts condition;
 export declare const isObject: <Values = unknown>(x: unknown) => x is Record<string, Values>;
+export declare const isPlainObject: <Values = unknown>(x: unknown) => x is Record<string, Values>;
 export declare const isNull: (data: unknown) => data is null | undefined;
 export declare const strIntentionalError = "Intentional Error for Debugging";
 export declare const defaultAgentInfo: {

package/lib/utils/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loopCounterKey = exports.isStaticNodeData = exports.isComputedNodeData = exports.isNamedInputs = exports.defaultTestContext = exports.isLogicallyTrue = exports.debugResultKey = exports.agentInfoWrapper = exports.defaultAgentInfo = exports.strIntentionalError = exports.isNull = exports.isObject = exports.parseNodeName = exports.sleep = void 0;
+exports.loopCounterKey = exports.isStaticNodeData = exports.isComputedNodeData = exports.isNamedInputs = exports.defaultTestContext = exports.isLogicallyTrue = exports.debugResultKey = exports.agentInfoWrapper = exports.defaultAgentInfo = exports.strIntentionalError = exports.isNull = exports.isPlainObject = exports.isObject = exports.parseNodeName = exports.sleep = void 0;
 exports.assert = assert;
 const type_1 = require("../type");
 const GraphAILogger_1 = require("./GraphAILogger");
@@ -52,6 +52,17 @@ const isObject = (x) => {
     return x !== null && typeof x === "object";
 };
 exports.isObject = isObject;
+// Stricter than isObject: rejects arrays, Map, Date, class instances, etc., that
+// would otherwise pass `typeof === "object"` and confuse `Object.entries()`.
+// Realm-sensitive (compares against the current realm's Object.prototype),
+// which is fine for graph data sourced from JSON.parse or in-process construction.
+const isPlainObject = (x) => {
+    if (!(0, exports.isObject)(x) || Array.isArray(x))
+        return false;
+    const proto = Object.getPrototypeOf(x);
+    return proto === null || proto === Object.prototype;
+};
+exports.isPlainObject = isPlainObject;
 const isNull = (data) => {
     return data === null || data === undefined;
 };

package/lib/validators/common.js

@@ -15,6 +15,7 @@ exports.computedNodeAttributeKeys = [
     "graphLoader",
     "isResult",
     "priority",
+    "label",
     "if",
     "unless",
     "defaultValue",

package/lib/validators/computed_node_validator.js

@@ -8,6 +8,9 @@ const computedNodeValidator = (nodeData) => {
             throw new common_1.ValidationError("Computed node does not allow " + key);
         }
     });
+    if (nodeData.label !== undefined && typeof nodeData.label !== "string") {
+        throw new common_1.ValidationError("Computed node label must be a string");
+    }
     return true;
 };
 exports.computedNodeValidator = computedNodeValidator;

package/lib/validators/graph_data_validator.js

@@ -2,6 +2,46 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.graphDataValidator = exports.graphNodesValidator = void 0;
 const common_1 = require("./common");
+const utils_1 = require("../utils/utils");
+const concurrencyConfigKeys = ["global", "labels"];
+const validateConcurrencyValue = (value, fieldDescription) => {
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+        throw new common_1.ValidationError(`${fieldDescription} must be an integer`);
+    }
+    if (value < 1) {
+        throw new common_1.ValidationError(`${fieldDescription} must be a positive integer`);
+    }
+};
+const validateConcurrencyConfig = (concurrency) => {
+    if (typeof concurrency === "number") {
+        validateConcurrencyValue(concurrency, "Concurrency");
+        return;
+    }
+    if (!(0, utils_1.isPlainObject)(concurrency)) {
+        throw new common_1.ValidationError("Concurrency must be an integer");
+    }
+    for (const key of Object.keys(concurrency)) {
+        if (!concurrencyConfigKeys.includes(key)) {
+            throw new common_1.ValidationError(`Concurrency object does not allow ${key}`);
+        }
+    }
+    if (!("global" in concurrency)) {
+        throw new common_1.ValidationError("Concurrency object must have a global field");
+    }
+    validateConcurrencyValue(concurrency.global, "Concurrency.global");
+    // The schema declares labels?: Record<string, number>. undefined is the only
+    // sentinel for "absent"; null, arrays, Maps, Dates and other non-plain-object
+    // shapes are malformed and would silently disable label enforcement (their
+    // Object.entries() yields no string keys).
+    if (concurrency.labels !== undefined) {
+        if (!(0, utils_1.isPlainObject)(concurrency.labels)) {
+            throw new common_1.ValidationError("Concurrency.labels must be an object");
+        }
+        for (const [labelKey, labelValue] of Object.entries(concurrency.labels)) {
+            validateConcurrencyValue(labelValue, `Concurrency.labels.${labelKey}`);
+        }
+    }
+};
 const graphNodesValidator = (data) => {
     if (data.nodes === undefined) {
         throw new common_1.ValidationError("Invalid Graph Data: no nodes");
@@ -32,12 +72,7 @@ const graphDataValidator = (data) => {
         }
     }
     if (data.concurrency !== undefined) {
-        if (!Number.isInteger(data.concurrency)) {
-            throw new common_1.ValidationError("Concurrency must be an integer");
-        }
-        if (data.concurrency < 1) {
-            throw new common_1.ValidationError("Concurrency must be a positive integer");
-        }
+        validateConcurrencyConfig(data.concurrency);
     }
 };
 exports.graphDataValidator = graphDataValidator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphai",
-  "version": "2.0.16",
+  "version": "2.0.17",
   "description": "Asynchronous data flow execution engine for agentic AI apps.",
   "main": "lib/index.js",
   "files": [
@@ -14,7 +14,8 @@
     "doc": "echo nothing",
     "format": "prettier --write '{src,tests}/**/*.ts' *.mjs",
     "test": "node --test --require ts-node/register ./tests/**/test_*.ts",
-    "b": "yarn run format && yarn run eslint && yarn run build"
+    "b": "yarn run format && yarn run eslint && yarn run build",
+    "prepack": "yarn build"
   },
   "repository": {
     "type": "git",
@@ -27,12 +28,15 @@
   },
   "homepage": "https://github.com/receptron/graphai#readme",
   "devDependencies": {
-    "typedoc": "^0.28.13",
-    "typedoc-plugin-markdown": "^4.9.0"
+    "typedoc": "^0.28.18",
+    "typedoc-plugin-markdown": "^4.11.0"
   },
   "types": "./lib/index.d.ts",
   "directories": {
     "lib": "lib",
     "test": "tests"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }