@scout9/app 1.0.0-alpha.0.1.99 → 1.0.0-alpha.0.2.0

package/dist/{dev-1afc1e7b.cjs → dev-df823c44.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var spirits = require("./spirits-43ce19cf.cjs");
+var spirits = require("./spirits-76855e30.cjs");
 var require$$0$4 = require('util');
 var require$$0$3 = require('stream');
 var require$$1 = require('path');
@@ -39939,7 +39939,7 @@ function _loadUserPackageJson() {
           targetPkgUrl = isTest ? packageTestJsonUrl : packageJsonUrl;
           _context2.t0 = JSON;
           _context2.next = 10;
-          return fs__default["default"].readFile(new URL(targetPkgUrl, (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('dev-1afc1e7b.js', document.baseURI).href))), 'utf-8');
+          return fs__default["default"].readFile(new URL(targetPkgUrl, (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('dev-df823c44.js', document.baseURI).href))), 'utf-8');
         case 10:
           _context2.t1 = _context2.sent;
           pkg = _context2.t0.parse.call(_context2.t0, _context2.t1);
@@ -40767,13 +40767,22 @@ z.object({
   bus: Bus
 });
 
-var WorkflowConfigurationSchema = z.object({
-  entities: z.array(zId('Workflow Folder', z.string()), {
-    description: 'Workflow id association, used to handle route params'
-  }).min(1, 'Must have at least 1 entity').max(15, 'Cannot have more than 15 entity paths'),
-  entity: zId('Workflow Folder', z.string())
+var ConversationContext = z.record(z.string(), z.any());
+var ConversationAnticipateSchema = z.object({
+  type: z["enum"](['did', 'literal', 'context'], {
+    description: "Determines the runtime to address the next response"
+  }),
+  slots: z.record(z.string(), z.array(z.any())),
+  did: z.string({
+    description: 'For type \'did\''
+  }).optional(),
+  map: z.array(z.object({
+    slot: z.string(),
+    keywords: z.array(z.string())
+  }), {
+    description: 'For literal keywords, this map helps point which slot the keyword matches to'
+  }).optional()
 });
-var WorkflowsConfigurationSchema = z.array(WorkflowConfigurationSchema);
 var ConversationSchema = z.object({
   $agent: zId('Conversation Agent ID', z.string({
     description: 'Default agent assigned to the conversation(s)'
@@ -40814,34 +40823,10 @@ var ConversationSchema = z.object({
   }).optional().nullable(),
   intentScore: z.number({
     description: 'Confidence score of the assigned intent'
-  }).optional().nullable()
-});
-var IntentWorkflowEventSchema = z.object({
-  current: z.string().nullable(),
-  flow: z.array(z.string()),
-  initial: z.string().nullable()
-});
-var WorkflowEventSchema = z.object({
-  messages: z.array(MessageSchema),
-  conversation: ConversationSchema,
-  context: z.any(),
-  message: MessageSchema,
-  agent: AgentConfigurationSchema.omit({
-    transcripts: true,
-    audios: true,
-    includedLocations: true,
-    excludedLocations: true,
-    model: true,
-    context: true
-  }),
-  customer: CustomerSchema,
-  intent: IntentWorkflowEventSchema,
-  stagnationCount: z.number(),
-  note: z.string({
-    description: 'Any developer notes to provide'
-  }).optional()
+  }).optional().nullable(),
+  anticipate: ConversationAnticipateSchema.optional()
 });
-var ConversationContext = z.record(z.string(), z.any());
+
 var ForwardSchema = z.union([z["boolean"](), z.string(), z.object({
   to: z.string().optional(),
   mode: z["enum"](['after-reply', 'immediately']).optional(),
@@ -40916,6 +40901,38 @@ var FollowupSchema = z.union([FollowupBaseSchema.extend({
 }), FollowupBaseSchema.extend({
   instructions: InstructionSchema
 })]);
+var WorkflowConfigurationSchema = z.object({
+  entities: z.array(zId('Workflow Folder', z.string()), {
+    description: 'Workflow id association, used to handle route params'
+  }).min(1, 'Must have at least 1 entity').max(15, 'Cannot have more than 15 entity paths'),
+  entity: zId('Workflow Folder', z.string())
+});
+var WorkflowsConfigurationSchema = z.array(WorkflowConfigurationSchema);
+var IntentWorkflowEventSchema = z.object({
+  current: z.string().nullable(),
+  flow: z.array(z.string()),
+  initial: z.string().nullable()
+});
+var WorkflowEventSchema = z.object({
+  messages: z.array(MessageSchema),
+  conversation: ConversationSchema,
+  context: z.any(),
+  message: MessageSchema,
+  agent: AgentConfigurationSchema.omit({
+    transcripts: true,
+    audios: true,
+    includedLocations: true,
+    excludedLocations: true,
+    model: true,
+    context: true
+  }),
+  customer: CustomerSchema,
+  intent: IntentWorkflowEventSchema,
+  stagnationCount: z.number(),
+  note: z.string({
+    description: 'Any developer notes to provide'
+  }).optional()
+});
 
 /**
  * The workflow response object slot
@@ -41530,8 +41547,8 @@ var Scout9ProjectBuildConfigSchema = Scout9ProjectConfigSchema.extend({
  * @property {Record<string, string>} params
  */
 var apiFunctionParamsSchema = z.object({
-  searchParams: z.record(z.union([z.string(), z.array(z.string())])),
-  params: z.record(z.string())
+  searchParams: z.record(z.string(), z.union([z.string(), z.array(z.string())])),
+  params: z.record(z.string(), z.string())
 });
 
 /**
@@ -41550,9 +41567,9 @@ z["function"]().args(apiFunctionParamsSchema).returns(z.promise(eventResponseSch
 
 var ContextExampleWithTrainingDataSchema = z.object({
   input: z.string(),
-  output: z.array(z.record(z.any()))
+  output: z.array(z.record(z.string(), z.any()))
 });
-z.union([z.array(ContextExampleWithTrainingDataSchema), z.array(z.record(z.any()))]);
+z.union([z.array(ContextExampleWithTrainingDataSchema), z.array(z.record(z.string(), z.any()))]);
 
 let FORCE_COLOR,
   NODE_DISABLE_COLORS,

package/dist/{index-2aedbf12.cjs → index-7460cfee.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var spirits = require("./spirits-43ce19cf.cjs");
-var dev = require("./dev-1afc1e7b.cjs");
+var spirits = require("./spirits-76855e30.cjs");
+var dev = require("./dev-df823c44.cjs");
 var require$$0 = require('fs');
 var require$$2$1 = require('events');
 var require$$1 = require('path');
@@ -29482,7 +29482,7 @@ class Body {
     }
     const {
       toFormData
-    } = await Promise.resolve().then(function () { return require("./multipart-parser-51d88fc4.cjs"); });
+    } = await Promise.resolve().then(function () { return require("./multipart-parser-d080fdee.cjs"); });
     return toFormData(this.body, ct);
   }
 
@@ -41891,7 +41891,7 @@ function _loadUserPackageJson() {
           targetPkgUrl = isTest ? packageTestJsonUrl : packageJsonUrl;
           _context.t0 = JSON;
           _context.next = 10;
-          return fs__default["default"].readFile(new URL(targetPkgUrl, (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index-2aedbf12.js', document.baseURI).href))), 'utf-8');
+          return fs__default["default"].readFile(new URL(targetPkgUrl, (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index-7460cfee.js', document.baseURI).href))), 'utf-8');
         case 10:
           _context.t1 = _context.sent;
           pkg = _context.t0.parse.call(_context.t0, _context.t1);
@@ -43097,7 +43097,7 @@ var ProjectFiles = /*#__PURE__*/function () {
   return ProjectFiles;
 }();
 
-var __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index-2aedbf12.js', document.baseURI).href)));
+var __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index-7460cfee.js', document.baseURI).href)));
 var __dirname$1 = path__default["default"].dirname(__filename$1);
 function zipDirectory(source, out) {
   var archive = archiver$1('tar', {
@@ -43312,7 +43312,7 @@ function _buildApp() {
         case 11:
           _context4.t0 = JSON;
           _context4.next = 14;
-          return fs__default["default"].readFile(new URL(templatePackagePath, (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index-2aedbf12.js', document.baseURI).href))), 'utf-8');
+          return fs__default["default"].readFile(new URL(templatePackagePath, (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index-7460cfee.js', document.baseURI).href))), 'utf-8');
         case 14:
           _context4.t1 = _context4.sent;
           packageTemplate = _context4.t0.parse.call(_context4.t0, _context4.t1);

package/dist/index.cjs

@@ -2,9 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index = require("./index-2aedbf12.cjs");
-var dev = require("./dev-1afc1e7b.cjs");
-require("./spirits-43ce19cf.cjs");
+var index = require("./index-7460cfee.cjs");
+var dev = require("./dev-df823c44.cjs");
+require("./spirits-76855e30.cjs");
 require('fs');
 require('events');
 require('path');

package/dist/{multipart-parser-51d88fc4.cjs → multipart-parser-d080fdee.cjs}

@@ -2,9 +2,9 @@
 
 require('node:fs');
 require('node:path');
-var index = require("./index-2aedbf12.cjs");
-require("./spirits-43ce19cf.cjs");
-require("./dev-1afc1e7b.cjs");
+var index = require("./index-7460cfee.cjs");
+require("./spirits-76855e30.cjs");
+require("./dev-df823c44.cjs");
 require('util');
 require('stream');
 require('path');

package/dist/{spirits-43ce19cf.cjs → spirits-76855e30.cjs}

@@ -572,6 +572,7 @@ function _classCheckPrivateStaticFieldDescriptor(descriptor, action) {
   }
 }
 
+var _excluded = ["keywords"];
 /**
  * @typedef {Object} Document
  * @property {string} id
@@ -667,6 +668,7 @@ function _classCheckPrivateStaticFieldDescriptor(descriptor, action) {
  * @property {Change<Array<import('@scout9/app').Message>>} messages
  * @property {Change<any>} context
  * @property {Change<import('@scout9/app').Message>} message
+ * @property {Array<import('@scout9/app').Followup>} followup
  */
 var Spirits = {
   /**
@@ -677,12 +679,13 @@ var Spirits = {
   customer: function () {
     var _customer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(input) {
       var _recentUserMessage;
-      var customer, config, parser, workflow, generator, idGenerator, _input$progress, progress, messageBefore, contextBefore, messagesBefore, conversationBefore, conversation, messages, context, message, updateConversation, updateContext, userMessages, recentUserMessage, lockConversation, incrementLockAttempt, _addInstruction, addInstruction, persona, invalidRoles, parsePayload, index, _message, previousUserMessages, oldKeyCount, newKeyCount, noNewContext, slots, hasNoInstructions, hasNoCustomMessage, previousLockAttempt, resettedIntent, _forward, _forwardNote, _iterator, _step, _step$value, forward, forwardNote, instructions, removeInstructions, manualMessage, scheduled, resetIntent, secondsDelay, contextUpsert, _iterator2, _step2, instruction, _iterator3, _step3, _loop, manualMessageObj, now, generatorPayload, agentMessages, lastAgentMessage;
+      var customer, config, parser, workflow, generator, idGenerator, _input$progress, progress, messageBefore, contextBefore, messagesBefore, conversationBefore, conversation, messages, context, message, followup, updateConversation, updateContext, userMessages, recentUserMessage, lockConversation, incrementLockAttempt, _addInstruction, addInstruction, persona, invalidRoles, parsePayload, index, _message, previousUserMessages, oldKeyCount, newKeyCount, noNewContext, slots, hasNoInstructions, hasNoCustomMessage, previousLockAttempt, resettedIntent, _forward, _forwardNote, _iterator, _step, _step$value, forward, forwardNote, instructions, removeInstructions, manualMessage, scheduled, resetIntent, secondsDelay, contextUpsert, anticipate, slotFollowup, _slots, map, i, _anticipate$i, keywords, _slot, slotId, _iterator2, _step2, instruction, _iterator3, _step3, _loop, manualMessageObj, now, generatorPayload, agentMessages, lastAgentMessage;
       return _regeneratorRuntime().wrap(function _callee$(_context2) {
         while (1) switch (_context2.prev = _context2.next) {
           case 0:
             customer = input.customer, config = input.config, parser = input.parser, workflow = input.workflow, generator = input.generator, idGenerator = input.idGenerator, _input$progress = input.progress, progress = _input$progress === void 0 ? function (message, level, type, payload) {} : _input$progress, messageBefore = input.message, contextBefore = input.context, messagesBefore = input.messages, conversationBefore = input.conversation;
-            conversation = input.conversation, messages = input.messages, context = input.context, message = input.message; // 0. Setup Helpers
+            conversation = input.conversation, messages = input.messages, context = input.context, message = input.message;
+            followup = []; // 0. Setup Helpers
             updateConversation = function updateConversation(previousConversation, conversationUpdates) {
               progress('Update conversation', 'info', 'UPDATE_CONVERSATION', conversationUpdates);
               return _objectSpread2(_objectSpread2({}, previousConversation), conversationUpdates);
@@ -771,40 +774,40 @@ var Spirits = {
               }
             }; // 1. Check inputs
             if (conversation.$agent) {
-              _context2.next = 12;
+              _context2.next = 13;
               break;
             }
             throw new Error("SpiritsError: No agent found in conversation, must define \".$agent\" in the conversation");
-          case 12:
+          case 13:
             persona = (config.persona || config.agents).find(function (p) {
               return p.id === conversation.$agent;
             });
             if (persona) {
-              _context2.next = 17;
+              _context2.next = 18;
               break;
             }
             if (!(config.persona || config.agents).some(function (a) {
               return !a.id;
             })) {
-              _context2.next = 16;
+              _context2.next = 17;
               break;
             }
             throw new Error("SpiritsError: No persona found (\"".concat(conversation.$agent, "\") in provided config, some persona's did not contain an \"id\" (Internal Mapping Error)"));
-          case 16:
-            throw new Error("SpiritsError: No persona found (\"".concat(conversation.$agent, "\") in provided config"));
           case 17:
+            throw new Error("SpiritsError: No persona found (\"".concat(conversation.$agent, "\") in provided config"));
+          case 18:
             if (messages.every(function (m) {
               return !!m.id;
             })) {
-              _context2.next = 19;
+              _context2.next = 20;
               break;
             }
             throw new Error("SpiritsError: Every message must have an \".id\", ensure all messages have an id assigned before running");
-          case 19:
+          case 20:
             if (messages.every(function (m) {
               return m.role === 'customer' || m.role === 'agent' || m.role === 'system';
             })) {
-              _context2.next = 22;
+              _context2.next = 23;
               break;
             }
             invalidRoles = messages.filter(function (m) {
@@ -813,7 +816,7 @@ var Spirits = {
             throw new Error("SpiritsError: Every message must have a role of \"customer\", \"agent\", or \"system\". Got invalid roles: ".concat(invalidRoles.map(function (m) {
               return m.role;
             }).join(', ')));
-          case 22:
+          case 23:
             // if message is not in messages, then add it
             if (!messages.find(function (m) {
               return m.id === input.message.id;
@@ -823,9 +826,9 @@ var Spirits = {
 
             // 2. Parse the message
             progress('Parsing message', 'info', 'SET_PROCESSING', 'user');
-            _context2.next = 26;
+            _context2.next = 27;
             return parser(message.content, 'en');
-          case 26:
+          case 27:
             parsePayload = _context2.sent;
             if (parsePayload.intent) {
               message.intent = parsePayload.intent;
@@ -893,7 +896,7 @@ var Spirits = {
             }
             noNewContext = Object.keys(parsePayload.context).length === 0; // 3. Run the workflow
             progress('Running workflow', 'info', 'SET_PROCESSING', 'system');
-            _context2.next = 42;
+            _context2.next = 43;
             return workflow({
               messages: messages,
               conversation: conversation,
@@ -912,7 +915,7 @@ var Spirits = {
             }).then(function (res) {
               return Array.isArray(res) ? res : [res];
             });
-          case 42:
+          case 43:
             slots = _context2.sent;
             hasNoInstructions = slots.every(function (s) {
               return !s.instructions || Array.isArray(s) && s.instructions.length === 0;
@@ -935,14 +938,64 @@ var Spirits = {
             }
             resettedIntent = false;
             _iterator = _createForOfIteratorHelper(slots);
-            _context2.prev = 49;
+            _context2.prev = 50;
             _iterator.s();
-          case 51:
+          case 52:
             if ((_step = _iterator.n()).done) {
-              _context2.next = 97;
+              _context2.next = 112;
+              break;
+            }
+            _step$value = _step.value, forward = _step$value.forward, forwardNote = _step$value.forwardNote, instructions = _step$value.instructions, removeInstructions = _step$value.removeInstructions, manualMessage = _step$value.message, scheduled = _step$value.scheduled, resetIntent = _step$value.resetIntent, secondsDelay = _step$value.secondsDelay, contextUpsert = _step$value.contextUpsert, anticipate = _step$value.anticipate, slotFollowup = _step$value.followup;
+            if (!anticipate) {
+              _context2.next = 67;
+              break;
+            }
+            if (!Array.isArray(anticipate)) {
+              _context2.next = 62;
               break;
             }
-            _step$value = _step.value, forward = _step$value.forward, forwardNote = _step$value.forwardNote, instructions = _step$value.instructions, removeInstructions = _step$value.removeInstructions, manualMessage = _step$value.message, scheduled = _step$value.scheduled, resetIntent = _step$value.resetIntent, secondsDelay = _step$value.secondsDelay, contextUpsert = _step$value.contextUpsert;
+            // 'literal' anticipation
+            _slots = {};
+            map = [];
+            for (i = 0; i < anticipate.length; i++) {
+              _anticipate$i = anticipate[i], keywords = _anticipate$i.keywords, _slot = _objectWithoutProperties(_anticipate$i, _excluded);
+              slotId = "".concat(i);
+              _slots[slotId] = _slot;
+              map.push({
+                slot: slotId,
+                keywords: keywords
+              });
+            }
+            updateConversation(conversation, {
+              type: 'literal',
+              slots: _slots,
+              map: map
+            });
+            _context2.next = 67;
+            break;
+          case 62:
+            if (!('yes' in anticipate && 'no' in anticipate && 'did' in anticipate)) {
+              _context2.next = 66;
+              break;
+            }
+            // "did" anticipation
+            updateConversation(conversation, {
+              type: 'did',
+              slots: {
+                yes: anticipate.yes,
+                no: anticipate.no
+              },
+              did: anticipate.did
+            });
+            _context2.next = 67;
+            break;
+          case 66:
+            throw new Error("Invalid anticipate payload \"".concat(JSON.stringify(anticipate), "\""));
+          case 67:
+            if (slotFollowup) {
+              followup.push(slotFollowup);
+            }
+
             // Forward to agent or other agent
             if (forward) {
               conversation = lockConversation(conversation, 'App instructed forward');
@@ -986,19 +1039,19 @@ var Spirits = {
 
             // Insert instructions context
             if (!instructions) {
-              _context2.next = 69;
+              _context2.next = 84;
               break;
             }
             if (!(typeof instructions === 'string')) {
-              _context2.next = 59;
+              _context2.next = 74;
               break;
             }
             addInstruction(instructions, previousLockAttempt);
-            _context2.next = 69;
+            _context2.next = 84;
             break;
-          case 59:
+          case 74:
             if (!Array.isArray(instructions)) {
-              _context2.next = 64;
+              _context2.next = 79;
               break;
             }
             _iterator2 = _createForOfIteratorHelper(instructions);
@@ -1016,25 +1069,25 @@ var Spirits = {
             } finally {
               _iterator2.f();
             }
-            _context2.next = 69;
+            _context2.next = 84;
             break;
-          case 64:
+          case 79:
             if (!(_typeof(instructions) === 'object' && 'content' in instructions && 'id' in instructions)) {
-              _context2.next = 68;
+              _context2.next = 83;
               break;
             }
             addInstruction(instructions.content, previousLockAttempt, instructions.id);
-            _context2.next = 69;
+            _context2.next = 84;
             break;
-          case 68:
+          case 83:
             throw new Error('SpiritsError: instructions must be a string or array or {content: "", id: ""}');
-          case 69:
+          case 84:
             if (!removeInstructions) {
-              _context2.next = 86;
+              _context2.next = 101;
               break;
             }
             _iterator3 = _createForOfIteratorHelper(removeInstructions);
-            _context2.prev = 71;
+            _context2.prev = 86;
             _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
               var instructionId, index;
               return _regeneratorRuntime().wrap(function _loop$(_context) {
@@ -1057,29 +1110,29 @@ var Spirits = {
               }, _loop);
             });
             _iterator3.s();
-          case 74:
+          case 89:
             if ((_step3 = _iterator3.n()).done) {
-              _context2.next = 78;
+              _context2.next = 93;
               break;
             }
-            return _context2.delegateYield(_loop(), "t0", 76);
-          case 76:
-            _context2.next = 74;
+            return _context2.delegateYield(_loop(), "t0", 91);
+          case 91:
+            _context2.next = 89;
             break;
-          case 78:
-            _context2.next = 83;
+          case 93:
+            _context2.next = 98;
             break;
-          case 80:
-            _context2.prev = 80;
-            _context2.t1 = _context2["catch"](71);
+          case 95:
+            _context2.prev = 95;
+            _context2.t1 = _context2["catch"](86);
             _iterator3.e(_context2.t1);
-          case 83:
-            _context2.prev = 83;
+          case 98:
+            _context2.prev = 98;
             _iterator3.f();
-            return _context2.finish(83);
-          case 86:
+            return _context2.finish(98);
+          case 101:
             if (!manualMessage) {
-              _context2.next = 93;
+              _context2.next = 108;
               break;
             }
             manualMessageObj = {
@@ -1089,11 +1142,11 @@ var Spirits = {
               time: new Date().toISOString()
             };
             if (!(typeof manualMessage !== 'string')) {
-              _context2.next = 90;
+              _context2.next = 105;
               break;
             }
             throw new Error('Manual message must be of type "string"');
-          case 90:
+          case 105:
             if (scheduled) {
               manualMessageObj.time = new Date(scheduled * 1000).toISOString();
               manualMessageObj.scheduled = manualMessageObj.time;
@@ -1105,7 +1158,7 @@ var Spirits = {
             }
             messages.push(manualMessageObj);
             progress('Added manual message', 'info', 'ADD_MESSAGE', messages[messages.length - 1]);
-          case 93:
+          case 108:
             if (contextUpsert) {
               context = updateContext(context, contextUpsert);
               progress('Upserted context', 'info', 'UPDATE_CONTEXT', contextUpsert);
@@ -1113,21 +1166,21 @@ var Spirits = {
             if (resetIntent) {
               resettedIntent = true;
             }
-          case 95:
-            _context2.next = 51;
+          case 110:
+            _context2.next = 52;
             break;
-          case 97:
-            _context2.next = 102;
+          case 112:
+            _context2.next = 117;
             break;
-          case 99:
-            _context2.prev = 99;
-            _context2.t2 = _context2["catch"](49);
+          case 114:
+            _context2.prev = 114;
+            _context2.t2 = _context2["catch"](50);
             _iterator.e(_context2.t2);
-          case 102:
-            _context2.prev = 102;
+          case 117:
+            _context2.prev = 117;
             _iterator.f();
-            return _context2.finish(102);
-          case 105:
+            return _context2.finish(117);
+          case 120:
             if (resettedIntent && !_forward) {
               conversation.intent = null;
               conversation.intentScore = null;
@@ -1146,16 +1199,16 @@ var Spirits = {
             // 4. Generate response
             // If conversation previously locked, don't generate
             if (input.conversation.locked) {
-              _context2.next = 120;
+              _context2.next = 135;
               break;
             }
             if (!((!conversation.locked || !hasNoInstructions) && !!hasNoCustomMessage)) {
-              _context2.next = 120;
+              _context2.next = 135;
               break;
             }
-            _context2.prev = 108;
+            _context2.prev = 123;
             progress('Parsing message', 'info', 'SET_PROCESSING', 'system');
-            _context2.next = 112;
+            _context2.next = 127;
             return generator({
               messages: messages,
               persona: persona,
@@ -1163,7 +1216,7 @@ var Spirits = {
               llm: config.llm,
               pmt: config.pmt
             });
-          case 112:
+          case 127:
             generatorPayload = _context2.sent;
             if (!generatorPayload.send) {
               progress('Generated response', 'failed', undefined, {
@@ -1200,14 +1253,14 @@ var Spirits = {
                 }
               }
             }
-            _context2.next = 120;
+            _context2.next = 135;
             break;
-          case 116:
-            _context2.prev = 116;
-            _context2.t3 = _context2["catch"](108);
+          case 131:
+            _context2.prev = 131;
+            _context2.t3 = _context2["catch"](123);
             console.error("Locking conversation, error generating response: ".concat(_context2.t3.message));
             conversation = lockConversation(conversation, 'API: ' + _context2.t3.message);
-          case 120:
+          case 135:
             progress('Parsing message', 'info', 'SET_PROCESSING', null);
             return _context2.abrupt("return", {
               conversation: {
@@ -1227,13 +1280,14 @@ var Spirits = {
               context: {
                 before: contextBefore,
                 after: context
-              }
+              },
+              followup: followup
             });
-          case 122:
+          case 137:
           case "end":
             return _context2.stop();
         }
-      }, _callee, null, [[49, 99, 102, 105], [71, 80, 83, 86], [108, 116]]);
+      }, _callee, null, [[50, 114, 117, 120], [86, 95, 98, 101], [123, 131]]);
     }));
     function customer(_x) {
       return _customer.apply(this, arguments);

package/dist/spirits.cjs

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var spirits = require("./spirits-43ce19cf.cjs");
+var spirits = require("./spirits-76855e30.cjs");
 
 
 

package/dist/testing-tools.cjs

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var dev = require("./dev-1afc1e7b.cjs");
-require("./spirits-43ce19cf.cjs");
+var dev = require("./dev-df823c44.cjs");
+require("./spirits-76855e30.cjs");
 require('util');
 require('stream');
 require('path');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scout9/app",
-  "version": "1.0.0-alpha.0.1.99",
+  "version": "1.0.0-alpha.0.2.0",
   "description": "Build and deploy your Scout9 app for SMS auto replies",
   "publishConfig": {
     "access": "public"

package/src/public.d.ts

@@ -4,7 +4,7 @@
  * Application platform for managing auto reply workflows from personal communication methods
  *
  *
- * NOTE: This file was auto generated 7/10/2024, 2:51:29 PM
+ * NOTE: This file was auto generated 7/10/2024, 3:30:35 PM
  * Do not edit the file manually.
  */
 
@@ -491,6 +491,21 @@ export type ContextExampleWithTrainingData = {
     }[];
 };
 
+export type ConversationAnticipate = {
+    /** Determines the runtime to address the next response */
+    type: "did" | "literal" | "context";
+    slots: {
+        [x: string]: any[];
+    };
+    /** For type 'did' */
+    did?: string | undefined;
+    /** For literal keywords, this map helps point which slot the keyword matches to */
+    map?: {
+        slot: string;
+        keywords: string[];
+    }[] | undefined;
+};
+
 export type ConversationContext = {
     [x: string]: any;
 };
@@ -524,6 +539,20 @@ export type Conversation = {
     intent?: (string | undefined) | null;
     /** Confidence score of the assigned intent */
     intentScore?: (number | undefined) | null;
+    anticipate?: {
+        /** Determines the runtime to address the next response */
+        type: "did" | "literal" | "context";
+        slots: {
+            [x: string]: any[];
+        };
+        /** For type 'did' */
+        did?: string | undefined;
+        /** For literal keywords, this map helps point which slot the keyword matches to */
+        map?: {
+            slot: string;
+            keywords: string[];
+        }[] | undefined;
+    } | undefined;
 };
 
 export type Customer = {
@@ -1243,6 +1272,20 @@ export type WorkflowEvent = {
         intent?: (string | undefined) | null;
         /** Confidence score of the assigned intent */
         intentScore?: (number | undefined) | null;
+        anticipate?: {
+            /** Determines the runtime to address the next response */
+            type: "did" | "literal" | "context";
+            slots: {
+                [x: string]: any[];
+            };
+            /** For type 'did' */
+            did?: string | undefined;
+            /** For literal keywords, this map helps point which slot the keyword matches to */
+            map?: {
+                slot: string;
+                keywords: string[];
+            }[] | undefined;
+        } | undefined;
     };
     context?: any;
     message: {
@@ -1373,6 +1416,20 @@ export type WorkflowFunction = (args_0: {
         intent?: (string | undefined) | null;
         /** Confidence score of the assigned intent */
         intentScore?: (number | undefined) | null;
+        anticipate?: {
+            /** Determines the runtime to address the next response */
+            type: "did" | "literal" | "context";
+            slots: {
+                [x: string]: any[];
+            };
+            /** For type 'did' */
+            did?: string | undefined;
+            /** For literal keywords, this map helps point which slot the keyword matches to */
+            map?: {
+                slot: string;
+                keywords: string[];
+            }[] | undefined;
+        } | undefined;
     };
     context?: any;
     message: {

package/src/runtime/schemas/conversation.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { zId } from './utils.js';
+
+export const ConversationContext = z.record(z.string(), z.any());
+
+export const ConversationAnticipateSchema = z.object({
+  type: z.enum(['did', 'literal', 'context'], {description: "Determines the runtime to address the next response"}),
+  slots: z.record(z.string(), z.array(z.any())),
+  did: z.string({description: 'For type \'did\''}).optional(),
+  map: z.array(z.object({
+    slot: z.string(),
+    keywords: z.array(z.string())
+  }), {description: 'For literal keywords, this map helps point which slot the keyword matches to'}).optional()
+});
+
+export const ConversationSchema = z.object({
+  $agent: zId('Conversation Agent ID', z.string({description: 'Default agent assigned to the conversation(s)'})),
+  $customer: zId('Conversation Customer ID', z.string({description: 'Customer this conversation is with'})),
+  initialContexts: z.array(z.string(), {description: 'Initial contexts to load when starting the conversation'})
+    .optional(),
+  environment: z.enum(['phone', 'email', 'web']),
+  environmentProps: z.object({
+    subject: z.string({description: 'HTML Subject of the conversation'}).optional(),
+    platformEmailThreadId: z.string({description: 'Used to sync email messages with the conversation'}).optional()
+  }).optional(),
+  locked: z.boolean({description: 'Whether the conversation is locked or not'}).optional().nullable(),
+  lockedReason: z.string({description: 'Why this conversation was locked'}).optional().nullable(),
+  lockAttempts: z.number({description: 'Number attempts made until conversation is locked'}).optional().nullable(),
+  forwardedTo: z.string({description: 'What personaId/phone/email was forwarded'}).optional().nullable(),
+  forwarded: z.string({description: 'Datetime ISO 8601 timestamp when persona was forwarded'}).optional().nullable(),
+  forwardNote: z.string().optional().nullable(),
+  intent: z.string({description: 'Detected intent of conversation'}).optional().nullable(),
+  intentScore: z.number({description: 'Confidence score of the assigned intent'}).optional().nullable(),
+  anticipate: ConversationAnticipateSchema.optional()
+});

package/src/runtime/schemas/index.js

@@ -5,5 +5,6 @@ export * from './entity.js';
 export * from './message.js';
 export * from './workflow.js';
 export * from './platform.js';
+export * from './conversation.js';
 export * from './macros.js';
 

package/src/runtime/schemas/macros.js

@@ -2,11 +2,11 @@ import { z } from "zod";
 
 export const ContextExampleWithTrainingDataSchema = z.object({
   input: z.string(),
-  output: z.array(z.record(z.any())),
+  output: z.array(z.record(z.string(), z.any())),
 });
 
 export const ContextExampleSchema = z.union([
   z.array(ContextExampleWithTrainingDataSchema),
-  z.array(z.record(z.any())),
+  z.array(z.record(z.string(), z.any())),
 ]);
 

package/src/runtime/schemas/platform.js

@@ -8,8 +8,8 @@ import { eventResponseSchema } from './api.js';
  * @property {Record<string, string>} params
  */
 const apiFunctionParamsSchema = z.object({
-  searchParams: z.record(z.union([z.string(), z.array(z.string())])),
-  params: z.record(z.string())
+  searchParams: z.record(z.string(), z.union([z.string(), z.array(z.string())])),
+  params: z.record(z.string(), z.string())
 });
 
 /**

package/src/runtime/schemas/workflow.js

@@ -4,68 +4,9 @@ import { z } from 'zod';
 import { zId } from './utils.js';
 import { AgentConfigurationSchema, CustomerSchema } from './users.js';
 import { MessageSchema } from './message.js';
+import { ConversationSchema, ConversationContext } from './conversation.js';
 
 
-export const WorkflowConfigurationSchema = z.object({
-  entities: z.array(
-    zId('Workflow Folder', z.string()),
-    {description: 'Workflow id association, used to handle route params'}
-  )
-    .min(1, 'Must have at least 1 entity')
-    .max(15, 'Cannot have more than 15 entity paths'),
-  entity: zId('Workflow Folder', z.string())
-});
-
-export const WorkflowsConfigurationSchema = z.array(WorkflowConfigurationSchema);
-
-
-export const ConversationSchema = z.object({
-  $agent: zId('Conversation Agent ID', z.string({description: 'Default agent assigned to the conversation(s)'})),
-  $customer: zId('Conversation Customer ID', z.string({description: 'Customer this conversation is with'})),
-  initialContexts: z.array(z.string(), {description: 'Initial contexts to load when starting the conversation'})
-    .optional(),
-  environment: z.enum(['phone', 'email', 'web']),
-  environmentProps: z.object({
-    subject: z.string({description: 'HTML Subject of the conversation'}).optional(),
-    platformEmailThreadId: z.string({description: 'Used to sync email messages with the conversation'}).optional()
-  }).optional(),
-  locked: z.boolean({description: 'Whether the conversation is locked or not'}).optional().nullable(),
-  lockedReason: z.string({description: 'Why this conversation was locked'}).optional().nullable(),
-  lockAttempts: z.number({description: 'Number attempts made until conversation is locked'}).optional().nullable(),
-  forwardedTo: z.string({description: 'What personaId/phone/email was forwarded'}).optional().nullable(),
-  forwarded: z.string({description: 'Datetime ISO 8601 timestamp when persona was forwarded'}).optional().nullable(),
-  forwardNote: z.string().optional().nullable(),
-  intent: z.string({description: 'Detected intent of conversation'}).optional().nullable(),
-  intentScore: z.number({description: 'Confidence score of the assigned intent'}).optional().nullable()
-});
-
-export const IntentWorkflowEventSchema = z.object({
-  current: z.string().nullable(),
-  flow: z.array(z.string()),
-  initial: z.string().nullable()
-});
-
-export const WorkflowEventSchema = z.object({
-  messages: z.array(MessageSchema),
-  conversation: ConversationSchema,
-  context: z.any(),
-  message: MessageSchema,
-  agent: AgentConfigurationSchema.omit({
-    transcripts: true,
-    audios: true,
-    includedLocations: true,
-    excludedLocations: true,
-    model: true,
-    context: true
-  }),
-  customer: CustomerSchema,
-  intent: IntentWorkflowEventSchema,
-  stagnationCount: z.number(),
-  note: z.string({description: 'Any developer notes to provide'}).optional()
-});
-
-export const ConversationContext = z.record(z.string(), z.any());
-
 export const ForwardSchema = z.union([
   z.boolean(),
   z.string(),
@@ -160,6 +101,44 @@ export const FollowupSchema = z.union([
   })
 ]);
 
+
+export const WorkflowConfigurationSchema = z.object({
+  entities: z.array(
+    zId('Workflow Folder', z.string()),
+    {description: 'Workflow id association, used to handle route params'}
+  )
+    .min(1, 'Must have at least 1 entity')
+    .max(15, 'Cannot have more than 15 entity paths'),
+  entity: zId('Workflow Folder', z.string())
+});
+
+export const WorkflowsConfigurationSchema = z.array(WorkflowConfigurationSchema);
+
+export const IntentWorkflowEventSchema = z.object({
+  current: z.string().nullable(),
+  flow: z.array(z.string()),
+  initial: z.string().nullable()
+});
+
+export const WorkflowEventSchema = z.object({
+  messages: z.array(MessageSchema),
+  conversation: ConversationSchema,
+  context: z.any(),
+  message: MessageSchema,
+  agent: AgentConfigurationSchema.omit({
+    transcripts: true,
+    audios: true,
+    includedLocations: true,
+    excludedLocations: true,
+    model: true,
+    context: true
+  }),
+  customer: CustomerSchema,
+  intent: IntentWorkflowEventSchema,
+  stagnationCount: z.number(),
+  note: z.string({description: 'Any developer notes to provide'}).optional()
+});
+
 /**
  * The workflow response object slot
  */

package/src/testing-tools/spirits.js

@@ -94,6 +94,7 @@
  * @property {Change<Array<import('@scout9/app').Message>>} messages
  * @property {Change<any>} context
  * @property {Change<import('@scout9/app').Message>} message
+ * @property {Array<import('@scout9/app').Followup>} followup
  */
 export const Spirits = {
 
@@ -118,6 +119,7 @@ export const Spirits = {
       conversation: conversationBefore
     } = input;
     let {conversation, messages, context, message} = input;
+    const followup = [];
 
     // 0. Setup Helpers
     const updateConversation = (previousConversation, conversationUpdates) => {
@@ -360,9 +362,50 @@ export const Spirits = {
       scheduled,
       resetIntent,
       secondsDelay,
-      contextUpsert
+      contextUpsert,
+      anticipate,
+      followup: slotFollowup,
     } of slots) {
 
+      // Anticipate customer response
+      if (anticipate) {
+        if (Array.isArray(anticipate)) {
+          // 'literal' anticipation
+          const slots = {};
+          const map = [];
+          for (let i = 0; i < anticipate.length; i++) {
+            const {keywords, ..._slot} = anticipate[i];
+            const slotId = `${i}`;
+            slots[slotId] = _slot;
+            map.push({
+              slot: slotId,
+              keywords
+            });
+          }
+          updateConversation(conversation, {
+            type: 'literal',
+            slots,
+            map
+          });
+        } else if ('yes' in anticipate && 'no' in anticipate && 'did' in anticipate) {
+          // "did" anticipation
+          updateConversation(conversation, {
+            type: 'did',
+            slots: {
+              yes: anticipate.yes,
+              no: anticipate.no
+            },
+            did: anticipate.did,
+          });
+        } else {
+          throw new Error(`Invalid anticipate payload "${JSON.stringify(anticipate)}"`);
+        }
+      }
+
+      if (slotFollowup) {
+        followup.push(slotFollowup);
+      }
+
       // Forward to agent or other agent
       if (forward) {
         conversation = lockConversation(conversation, 'App instructed forward');
@@ -564,7 +607,8 @@ export const Spirits = {
       context: {
         before: contextBefore,
         after: context
-      }
+      },
+      followup
     };
   }
 };

package/types/index.d.ts

@@ -4,7 +4,7 @@ declare module '@scout9/app' {
 	 * Application platform for managing auto reply workflows from personal communication methods
 	 *
 	 *
-	 * NOTE: This file was auto generated 7/10/2024, 2:51:29 PM
+	 * NOTE: This file was auto generated 7/10/2024, 3:30:35 PM
 	 * Do not edit the file manually.
 	 */
 
@@ -454,6 +454,21 @@ declare module '@scout9/app' {
 		}[];
 	};
 
+	export type ConversationAnticipate = {
+		/** Determines the runtime to address the next response */
+		type: "did" | "literal" | "context";
+		slots: {
+			[x: string]: any[];
+		};
+		/** For type 'did' */
+		did?: string | undefined;
+		/** For literal keywords, this map helps point which slot the keyword matches to */
+		map?: {
+			slot: string;
+			keywords: string[];
+		}[] | undefined;
+	};
+
 	export type ConversationContext = {
 		[x: string]: any;
 	};
@@ -487,6 +502,20 @@ declare module '@scout9/app' {
 		intent?: (string | undefined) | null;
 		/** Confidence score of the assigned intent */
 		intentScore?: (number | undefined) | null;
+		anticipate?: {
+			/** Determines the runtime to address the next response */
+			type: "did" | "literal" | "context";
+			slots: {
+				[x: string]: any[];
+			};
+			/** For type 'did' */
+			did?: string | undefined;
+			/** For literal keywords, this map helps point which slot the keyword matches to */
+			map?: {
+				slot: string;
+				keywords: string[];
+			}[] | undefined;
+		} | undefined;
 	};
 
 	export type Customer = {
@@ -1206,6 +1235,20 @@ declare module '@scout9/app' {
 			intent?: (string | undefined) | null;
 			/** Confidence score of the assigned intent */
 			intentScore?: (number | undefined) | null;
+			anticipate?: {
+				/** Determines the runtime to address the next response */
+				type: "did" | "literal" | "context";
+				slots: {
+					[x: string]: any[];
+				};
+				/** For type 'did' */
+				did?: string | undefined;
+				/** For literal keywords, this map helps point which slot the keyword matches to */
+				map?: {
+					slot: string;
+					keywords: string[];
+				}[] | undefined;
+			} | undefined;
 		};
 		context?: any;
 		message: {
@@ -1336,6 +1379,20 @@ declare module '@scout9/app' {
 			intent?: (string | undefined) | null;
 			/** Confidence score of the assigned intent */
 			intentScore?: (number | undefined) | null;
+			anticipate?: {
+				/** Determines the runtime to address the next response */
+				type: "did" | "literal" | "context";
+				slots: {
+					[x: string]: any[];
+				};
+				/** For type 'did' */
+				did?: string | undefined;
+				/** For literal keywords, this map helps point which slot the keyword matches to */
+				map?: {
+					slot: string;
+					keywords: string[];
+				}[] | undefined;
+			} | undefined;
 		};
 		context?: any;
 		message: {
@@ -3518,6 +3575,7 @@ declare module '@scout9/app/spirits' {
 		messages: Change<Array<import('@scout9/app').Message>>;
 		context: Change<any>;
 		message: Change<import('@scout9/app').Message>;
+		followup: Array<import('@scout9/app').Followup>;
 	};
 }
 

package/types/index.d.ts.map

@@ -28,6 +28,7 @@
 		"Bus",
 		"ContextExample",
 		"ContextExampleWithTrainingData",
+		"ConversationAnticipate",
 		"ConversationContext",
 		"Conversation",
 		"Customer",
@@ -83,5 +84,5 @@
 		null,
 		null
 	],
-	"mappings": "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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA0mChBC,uBAAuBA;;;;;;;;;aASvBC,iCAAiCA;;;;;;;;;aASjCC,kCAAkCA;;;;;;;;;;;;;;aAclCC,gBAAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAsfhBC,wBAAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA+DxBC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA4PpBC,sBAAsBA;;;;;;aAMtBC,WAAWA;;;;;;;;;;;;;;;;aAgBXC,iBAAiBA;;;;;;;;;;;;;;;;aAgBjBC,aAAaA;;;;;;;;;aASbC,cAAcA;;;;;;;;;;;;;;;;aAgBdC,gBAAgBA;;;;;;;;;;;;;;;;;;iBCnyGfC,eAAeA;iBAWfC,kBAAkBA;iBAgBlBC,iBAAiBA;iBAcjBC,sBAAsBA;iBAatBC,uBAAuBA;;;;;cC/CvBC,UAAUA"
+	"mappings": "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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAwnChBC,uBAAuBA;;;;;;;;;aASvBC,iCAAiCA;;;;;;;;;aASjCC,kCAAkCA;;;;;;;;;;;;;;aAclCC,gBAAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAsfhBC,wBAAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA+DxBC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA4PpBC,sBAAsBA;;;;;;aAMtBC,WAAWA;;;;;;;;;;;;;;;;aAgBXC,iBAAiBA;;;;;;;;;;;;;;;;aAgBjBC,aAAaA;;;;;;;;;aASbC,cAAcA;;;;;;;;;;;;;;;;aAgBdC,gBAAgBA;;;;;;;;;;;;;;;;;;iBC51GfC,eAAeA;iBAWfC,kBAAkBA;iBAgBlBC,iBAAiBA;iBAcjBC,sBAAsBA;iBAatBC,uBAAuBA;;;;;cC/CvBC,UAAUA"
 }