yaml-flow 2.4.0 → 2.5.0

package/dist/index.d.cts

@@ -1,10 +1,12 @@
 export { StepMachine as FlowEngine, StepMachine, applyStepResult, checkCircuitBreaker, computeStepInput, createStepMachine as createEngine, createInitialState, createStepMachine, extractReturnData, loadStepFlow, validateStepFlowConfig } from './step-machine/index.cjs';
 export { C as CircuitBreakerConfig, R as RetryConfig, S as StepConfig, a as StepContext, b as StepEvent, c as StepEventListener, d as StepEventType, e as StepFlowConfig, f as StepFlowSettings, g as StepHandler, h as StepInput, i as StepMachineOptions, j as StepMachineResult, k as StepMachineState, l as StepMachineStore, m as StepReducerResult, n as StepResult, T as TerminalStateConfig } from './types-FZ_eyErS.cjs';
-export { C as COMPLETION_STRATEGIES, a as CONFLICT_STRATEGIES, b as CompletionResult, D as DEFAULTS, E as EXECUTION_MODES, c as EXECUTION_STATUS, d as ExecutionPlan, e as ExportOptions, G as GraphIssue, f as GraphValidationResult, I as IssueSeverity, M as MermaidOptions, T as TASK_STATUS, g as addDynamicTask, h as apply, i as applyAll, j as computeAvailableOutputs, k as createDefaultTaskState, l as createInitialExecutionState, m as detectStuckState, n as exportGraphConfig, o as exportGraphConfigToFile, p as flowToMermaid, q as getAllTasks, r as getCandidateTasks, s as getProvides, t as getRequires, u as getTask, v as graphToMermaid, w as hasTask, x as isExecutionComplete, y as isNonActiveTask, z as isRepeatableTask, A as isTaskCompleted, B as isTaskRunning, F as loadGraphConfig, H as next, J as planExecution, K as validateGraph, L as validateGraphConfig } from './constants-Dbk6ArN5.cjs';
-export { A as AgentActionEvent, C as CompletionStrategy, a as ConflictStrategy, E as ExecutionConfig, b as ExecutionMode, c as ExecutionState, d as ExecutionStatus, G as GraphConfig, e as GraphEvent, f as GraphSettings, T as GraphTaskConfig, I as InjectTokensEvent, S as SchedulerResult, g as StuckDetection, h as TaskCompletedEvent, i as TaskCreationEvent, j as TaskFailedEvent, k as TaskStartedEvent, l as TaskState, m as TaskStatus } from './types-CTu8RqY0.cjs';
+export { C as COMPLETION_STRATEGIES, a as CONFLICT_STRATEGIES, b as CompletionResult, D as DEFAULTS, E as EXECUTION_MODES, c as EXECUTION_STATUS, d as ExecutionPlan, e as ExportOptions, G as GraphIssue, f as GraphValidationResult, I as IssueSeverity, M as MermaidOptions, T as TASK_STATUS, g as addDynamicTask, h as apply, i as applyAll, j as computeAvailableOutputs, k as createDefaultTaskState, l as createInitialExecutionState, m as detectStuckState, n as exportGraphConfig, o as exportGraphConfigToFile, p as flowToMermaid, q as getAllTasks, r as getCandidateTasks, s as getProvides, t as getRequires, u as getTask, v as graphToMermaid, w as hasTask, x as isExecutionComplete, y as isNonActiveTask, z as isRepeatableTask, A as isTaskCompleted, B as isTaskRunning, F as loadGraphConfig, H as next, J as planExecution, K as validateGraph, L as validateGraphConfig } from './constants-BNjeIlZ8.cjs';
+export { A as AgentActionEvent, C as CompletionStrategy, a as ConflictStrategy, E as ExecutionConfig, b as ExecutionMode, c as ExecutionState, d as ExecutionStatus, G as GraphConfig, e as GraphEvent, f as GraphSettings, T as GraphTaskConfig, I as InjectTokensEvent, S as SchedulerResult, g as StuckDetection, h as TaskCompletedEvent, i as TaskCreationEvent, j as TaskFailedEvent, k as TaskStartedEvent, l as TaskState, m as TaskStatus } from './types-DAI_a2as.cjs';
 export { MemoryStore } from './stores/memory.cjs';
 export { LocalStorageStore } from './stores/localStorage.cjs';
 export { FileStore } from './stores/file.cjs';
 export { BatchItemResult, BatchOptions, BatchProgress, BatchResult, batch } from './batch/index.cjs';
 export { ConfigTemplates, Variables, resolveConfigTemplates, resolveVariables } from './config/index.cjs';
-export { BlockedTask, DownstreamResult, LiveGraph, LiveGraphHealth, LiveGraphSnapshot, NodeInfo, PendingTask, ScheduleResult, UnreachableNodesResult, UnreachableTokensResult, UnresolvedDependency, UpstreamResult, addNode, addProvides, addRequires, applyEvent, createLiveGraph, disableNode, drainTokens, enableNode, getDownstream, getNode, getUnreachableNodes, getUnreachableTokens, getUpstream, injectTokens, inspect, removeNode, removeProvides, removeRequires, resetNode, restore, schedule, snapshot } from './continuous-event-graph/index.cjs';
+export { addNode, addProvides, addRequires, applyEvent, createLiveGraph, disableNode, drainTokens, enableNode, getDownstream, getNode, getUnreachableNodes, getUnreachableTokens, getUpstream, injectTokens, inspect, removeNode, removeProvides, removeRequires, resetNode, restore, schedule, snapshot } from './continuous-event-graph/index.cjs';
+export { B as BlockedTask, D as DownstreamResult, L as LiveGraph, a as LiveGraphHealth, b as LiveGraphSnapshot, N as NodeInfo, P as PendingTask, S as ScheduleResult, U as UnreachableNodesResult, c as UnreachableTokensResult, d as UnresolvedDependency, e as UpstreamResult } from './types-C2lOwquM.cjs';
+export { CliAdapterOptions, HttpAdapterOptions, InferAndApplyResult, InferenceAdapter, InferenceHints, InferenceOptions, InferenceResult, InferredCompletion, applyInferences, buildInferencePrompt, createCliAdapter, createHttpAdapter, inferAndApply, inferCompletions } from './inference/index.cjs';

package/dist/index.d.ts

@@ -1,10 +1,12 @@
 export { StepMachine as FlowEngine, StepMachine, applyStepResult, checkCircuitBreaker, computeStepInput, createStepMachine as createEngine, createInitialState, createStepMachine, extractReturnData, loadStepFlow, validateStepFlowConfig } from './step-machine/index.js';
 export { C as CircuitBreakerConfig, R as RetryConfig, S as StepConfig, a as StepContext, b as StepEvent, c as StepEventListener, d as StepEventType, e as StepFlowConfig, f as StepFlowSettings, g as StepHandler, h as StepInput, i as StepMachineOptions, j as StepMachineResult, k as StepMachineState, l as StepMachineStore, m as StepReducerResult, n as StepResult, T as TerminalStateConfig } from './types-FZ_eyErS.js';
-export { C as COMPLETION_STRATEGIES, a as CONFLICT_STRATEGIES, b as CompletionResult, D as DEFAULTS, E as EXECUTION_MODES, c as EXECUTION_STATUS, d as ExecutionPlan, e as ExportOptions, G as GraphIssue, f as GraphValidationResult, I as IssueSeverity, M as MermaidOptions, T as TASK_STATUS, g as addDynamicTask, h as apply, i as applyAll, j as computeAvailableOutputs, k as createDefaultTaskState, l as createInitialExecutionState, m as detectStuckState, n as exportGraphConfig, o as exportGraphConfigToFile, p as flowToMermaid, q as getAllTasks, r as getCandidateTasks, s as getProvides, t as getRequires, u as getTask, v as graphToMermaid, w as hasTask, x as isExecutionComplete, y as isNonActiveTask, z as isRepeatableTask, A as isTaskCompleted, B as isTaskRunning, F as loadGraphConfig, H as next, J as planExecution, K as validateGraph, L as validateGraphConfig } from './constants-DcCDDQON.js';
-export { A as AgentActionEvent, C as CompletionStrategy, a as ConflictStrategy, E as ExecutionConfig, b as ExecutionMode, c as ExecutionState, d as ExecutionStatus, G as GraphConfig, e as GraphEvent, f as GraphSettings, T as GraphTaskConfig, I as InjectTokensEvent, S as SchedulerResult, g as StuckDetection, h as TaskCompletedEvent, i as TaskCreationEvent, j as TaskFailedEvent, k as TaskStartedEvent, l as TaskState, m as TaskStatus } from './types-CTu8RqY0.js';
+export { C as COMPLETION_STRATEGIES, a as CONFLICT_STRATEGIES, b as CompletionResult, D as DEFAULTS, E as EXECUTION_MODES, c as EXECUTION_STATUS, d as ExecutionPlan, e as ExportOptions, G as GraphIssue, f as GraphValidationResult, I as IssueSeverity, M as MermaidOptions, T as TASK_STATUS, g as addDynamicTask, h as apply, i as applyAll, j as computeAvailableOutputs, k as createDefaultTaskState, l as createInitialExecutionState, m as detectStuckState, n as exportGraphConfig, o as exportGraphConfigToFile, p as flowToMermaid, q as getAllTasks, r as getCandidateTasks, s as getProvides, t as getRequires, u as getTask, v as graphToMermaid, w as hasTask, x as isExecutionComplete, y as isNonActiveTask, z as isRepeatableTask, A as isTaskCompleted, B as isTaskRunning, F as loadGraphConfig, H as next, J as planExecution, K as validateGraph, L as validateGraphConfig } from './constants-BEbO2_OK.js';
+export { A as AgentActionEvent, C as CompletionStrategy, a as ConflictStrategy, E as ExecutionConfig, b as ExecutionMode, c as ExecutionState, d as ExecutionStatus, G as GraphConfig, e as GraphEvent, f as GraphSettings, T as GraphTaskConfig, I as InjectTokensEvent, S as SchedulerResult, g as StuckDetection, h as TaskCompletedEvent, i as TaskCreationEvent, j as TaskFailedEvent, k as TaskStartedEvent, l as TaskState, m as TaskStatus } from './types-DAI_a2as.js';
 export { MemoryStore } from './stores/memory.js';
 export { LocalStorageStore } from './stores/localStorage.js';
 export { FileStore } from './stores/file.js';
 export { BatchItemResult, BatchOptions, BatchProgress, BatchResult, batch } from './batch/index.js';
 export { ConfigTemplates, Variables, resolveConfigTemplates, resolveVariables } from './config/index.js';
-export { BlockedTask, DownstreamResult, LiveGraph, LiveGraphHealth, LiveGraphSnapshot, NodeInfo, PendingTask, ScheduleResult, UnreachableNodesResult, UnreachableTokensResult, UnresolvedDependency, UpstreamResult, addNode, addProvides, addRequires, applyEvent, createLiveGraph, disableNode, drainTokens, enableNode, getDownstream, getNode, getUnreachableNodes, getUnreachableTokens, getUpstream, injectTokens, inspect, removeNode, removeProvides, removeRequires, resetNode, restore, schedule, snapshot } from './continuous-event-graph/index.js';
+export { addNode, addProvides, addRequires, applyEvent, createLiveGraph, disableNode, drainTokens, enableNode, getDownstream, getNode, getUnreachableNodes, getUnreachableTokens, getUpstream, injectTokens, inspect, removeNode, removeProvides, removeRequires, resetNode, restore, schedule, snapshot } from './continuous-event-graph/index.js';
+export { B as BlockedTask, D as DownstreamResult, L as LiveGraph, a as LiveGraphHealth, b as LiveGraphSnapshot, N as NodeInfo, P as PendingTask, S as ScheduleResult, U as UnreachableNodesResult, c as UnreachableTokensResult, d as UnresolvedDependency, e as UpstreamResult } from './types-mS_pPftm.js';
+export { CliAdapterOptions, HttpAdapterOptions, InferAndApplyResult, InferenceAdapter, InferenceHints, InferenceOptions, InferenceResult, InferredCompletion, applyInferences, buildInferencePrompt, createCliAdapter, createHttpAdapter, inferAndApply, inferCompletions } from './inference/index.js';

package/dist/index.js

@@ -1,3 +1,5 @@
+import { execFile } from 'child_process';
+
 // src/step-machine/reducer.ts
 function applyStepResult(flow, state, stepName, stepResult) {
   const stepConfig = flow.steps[stepName];
@@ -3027,6 +3029,257 @@ function getDownstream(live, nodeName) {
   return { nodeName, nodes, tokens: [...tokenSet] };
 }
 
-export { COMPLETION_STRATEGIES, CONFLICT_STRATEGIES, DEFAULTS, EXECUTION_MODES, EXECUTION_STATUS, FileStore, StepMachine as FlowEngine, LocalStorageStore, MemoryStore, StepMachine, TASK_STATUS, addDynamicTask, addNode, addProvides, addRequires, apply, applyAll, applyEvent, applyStepResult, batch, checkCircuitBreaker, computeAvailableOutputs, computeStepInput, createDefaultTaskState, createStepMachine as createEngine, createInitialExecutionState, createInitialState, createLiveGraph, createStepMachine, detectStuckState, disableNode, drainTokens, enableNode, exportGraphConfig, exportGraphConfigToFile, extractReturnData, flowToMermaid, getAllTasks, getCandidateTasks, getDownstream, getNode, getProvides, getRequires, getTask, getUnreachableNodes, getUnreachableTokens, getUpstream, graphToMermaid, hasTask, injectTokens, inspect, isExecutionComplete, isNonActiveTask, isRepeatableTask, isTaskCompleted, isTaskRunning, loadGraphConfig, loadStepFlow, next, planExecution, removeNode, removeProvides, removeRequires, resetNode, resolveConfigTemplates, resolveVariables, restore, schedule, snapshot, validateGraph, validateGraphConfig, validateStepFlowConfig };
+// src/inference/core.ts
+var DEFAULT_THRESHOLD = 0.5;
+var DEFAULT_SYSTEM_PROMPT = `You are a workflow completion analyzer. Given a graph of tasks with their current states, evidence, and inference hints, determine which tasks appear to be completed based on the available evidence.
+
+For each task you analyze, provide a JSON response. Be conservative \u2014 only mark tasks as completed when the evidence strongly supports it.`;
+function buildInferencePrompt(live, options = {}) {
+  const { scope, context, systemPrompt } = options;
+  const graphTasks = getAllTasks(live.config);
+  const { state } = live;
+  const candidates = getAnalyzableCandidates(live, scope);
+  if (candidates.length === 0) {
+    return "";
+  }
+  const lines = [];
+  lines.push(systemPrompt || DEFAULT_SYSTEM_PROMPT);
+  lines.push("");
+  lines.push("## Graph State");
+  lines.push("");
+  lines.push(`Available tokens: ${state.availableOutputs.length > 0 ? state.availableOutputs.join(", ") : "(none)"}`);
+  lines.push("");
+  const completedTasks = Object.entries(state.tasks).filter(([_, ts]) => ts.status === "completed").map(([name]) => name);
+  if (completedTasks.length > 0) {
+    lines.push(`Completed tasks: ${completedTasks.join(", ")}`);
+    lines.push("");
+  }
+  lines.push("## Tasks to Analyze");
+  lines.push("");
+  for (const taskName of candidates) {
+    const taskConfig = graphTasks[taskName];
+    const taskState = state.tasks[taskName];
+    lines.push(`### ${taskName}`);
+    if (taskConfig.description) {
+      lines.push(`Description: ${taskConfig.description}`);
+    }
+    const requires = getRequires(taskConfig);
+    const provides = getProvides(taskConfig);
+    if (requires.length > 0) lines.push(`Requires: ${requires.join(", ")}`);
+    if (provides.length > 0) lines.push(`Provides: ${provides.join(", ")}`);
+    lines.push(`Current status: ${taskState?.status || "not-started"}`);
+    const hints = taskConfig.inference;
+    if (hints) {
+      if (hints.criteria) lines.push(`Completion criteria: ${hints.criteria}`);
+      if (hints.keywords?.length) lines.push(`Keywords: ${hints.keywords.join(", ")}`);
+      if (hints.suggestedChecks?.length) lines.push(`Suggested checks: ${hints.suggestedChecks.join("; ")}`);
+    }
+    lines.push("");
+  }
+  if (context) {
+    lines.push("## Additional Context / Evidence");
+    lines.push("");
+    lines.push(context);
+    lines.push("");
+  }
+  lines.push("## Response Format");
+  lines.push("");
+  lines.push("Respond with a JSON array of objects, one per task you have evidence for:");
+  lines.push("```json");
+  lines.push("[");
+  lines.push("  {");
+  lines.push('    "taskName": "task-name",');
+  lines.push('    "confidence": 0.0 to 1.0,');
+  lines.push('    "reasoning": "explanation of why you believe this task is complete or not"');
+  lines.push("  }");
+  lines.push("]");
+  lines.push("```");
+  lines.push("");
+  lines.push("Rules:");
+  lines.push('- Only include tasks from the "Tasks to Analyze" section');
+  lines.push("- confidence 0.0 = no evidence of completion, 1.0 = certain it is complete");
+  lines.push("- If you have no evidence for a task, omit it from the array");
+  lines.push("- Be conservative \u2014 require clear evidence before high confidence");
+  lines.push("- Respond ONLY with the JSON array, no additional text");
+  return lines.join("\n");
+}
+async function inferCompletions(live, adapter, options = {}) {
+  options.threshold ?? DEFAULT_THRESHOLD;
+  const analyzedNodes = getAnalyzableCandidates(live, options.scope);
+  if (analyzedNodes.length === 0) {
+    return { suggestions: [], promptUsed: "", rawResponse: "", analyzedNodes: [] };
+  }
+  const prompt = buildInferencePrompt(live, options);
+  const rawResponse = await adapter.analyze(prompt);
+  const suggestions = parseInferenceResponse(rawResponse, analyzedNodes);
+  return {
+    suggestions,
+    promptUsed: prompt,
+    rawResponse,
+    analyzedNodes
+  };
+}
+function applyInferences(live, result, threshold = DEFAULT_THRESHOLD) {
+  let current = live;
+  for (const suggestion of result.suggestions) {
+    if (suggestion.confidence < threshold) continue;
+    const taskState = current.state.tasks[suggestion.taskName];
+    if (!taskState) continue;
+    if (taskState.status === "completed" || taskState.status === "running") continue;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    current = applyEvent(current, {
+      type: "task-started",
+      taskName: suggestion.taskName,
+      timestamp: now
+    });
+    current = applyEvent(current, {
+      type: "task-completed",
+      taskName: suggestion.taskName,
+      timestamp: now,
+      result: "llm-inferred"
+    });
+  }
+  return current;
+}
+async function inferAndApply(live, adapter, options = {}) {
+  const threshold = options.threshold ?? DEFAULT_THRESHOLD;
+  const inference = await inferCompletions(live, adapter, options);
+  const updated = applyInferences(live, inference, threshold);
+  const applied = inference.suggestions.filter((s) => s.confidence >= threshold);
+  const skipped = inference.suggestions.filter((s) => s.confidence < threshold);
+  return {
+    live: updated,
+    inference,
+    applied,
+    skipped
+  };
+}
+function getAnalyzableCandidates(live, scope) {
+  const graphTasks = getAllTasks(live.config);
+  const { state } = live;
+  const candidates = [];
+  for (const [name, config] of Object.entries(graphTasks)) {
+    const taskState = state.tasks[name];
+    if (taskState?.status === "completed" || taskState?.status === "running") continue;
+    if (scope) {
+      if (scope.includes(name)) candidates.push(name);
+    } else {
+      if (config.inference?.autoDetectable) candidates.push(name);
+    }
+  }
+  return candidates;
+}
+function parseInferenceResponse(rawResponse, validNodes, _threshold) {
+  const validSet = new Set(validNodes);
+  try {
+    const jsonStr = extractJson(rawResponse);
+    if (!jsonStr) return [];
+    const parsed = JSON.parse(jsonStr);
+    if (!Array.isArray(parsed)) return [];
+    const suggestions = [];
+    for (const item of parsed) {
+      if (!item || typeof item !== "object") continue;
+      if (typeof item.taskName !== "string") continue;
+      if (typeof item.confidence !== "number") continue;
+      if (!validSet.has(item.taskName)) continue;
+      const confidence = Math.max(0, Math.min(1, item.confidence));
+      suggestions.push({
+        taskName: item.taskName,
+        confidence,
+        reasoning: typeof item.reasoning === "string" ? item.reasoning : "",
+        detectionMethod: "llm-inferred"
+      });
+    }
+    return suggestions;
+  } catch {
+    return [];
+  }
+}
+function extractJson(text) {
+  if (!text || typeof text !== "string") return null;
+  const trimmed = text.trim();
+  const fenceMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+  if (fenceMatch) return fenceMatch[1].trim();
+  const firstBracket = trimmed.indexOf("[");
+  const lastBracket = trimmed.lastIndexOf("]");
+  if (firstBracket !== -1 && lastBracket > firstBracket) {
+    return trimmed.slice(firstBracket, lastBracket + 1);
+  }
+  if (trimmed.startsWith("[")) return trimmed;
+  return null;
+}
+function createCliAdapter(opts) {
+  const timeout = opts.timeout ?? 6e4;
+  return {
+    analyze: (prompt) => {
+      return new Promise((resolve, reject) => {
+        const args = opts.args(prompt);
+        const child = execFile(
+          opts.command,
+          opts.stdin ? opts.args("") : args,
+          {
+            timeout,
+            cwd: opts.cwd,
+            env: opts.env ? { ...process.env, ...opts.env } : void 0,
+            maxBuffer: 10 * 1024 * 1024
+            // 10MB
+          },
+          (error, stdout, stderr) => {
+            if (error) {
+              reject(new Error(
+                `CLI adapter failed: ${opts.command} exited with ${error.code ?? "error"}` + (stderr ? `
+stderr: ${stderr.slice(0, 500)}` : "") + `
+${error.message}`
+              ));
+            } else {
+              resolve(stdout);
+            }
+          }
+        );
+        if (opts.stdin && child.stdin) {
+          child.stdin.write(prompt);
+          child.stdin.end();
+        }
+      });
+    }
+  };
+}
+function createHttpAdapter(opts) {
+  const timeout = opts.timeout ?? 6e4;
+  return {
+    analyze: async (prompt) => {
+      const body = opts.buildBody ? opts.buildBody(prompt) : { prompt };
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      try {
+        const response = await fetch(opts.url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...opts.headers ?? {}
+          },
+          body: JSON.stringify(body),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const text = await response.text().catch(() => "");
+          throw new Error(`HTTP ${response.status}: ${text.slice(0, 500)}`);
+        }
+        const json = await response.json();
+        if (opts.extractResponse) {
+          return opts.extractResponse(json);
+        }
+        if (typeof json.response === "string") return json.response;
+        if (typeof json.text === "string") return json.text;
+        if (typeof json.content === "string") return json.content;
+        return JSON.stringify(json);
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+
+export { COMPLETION_STRATEGIES, CONFLICT_STRATEGIES, DEFAULTS, EXECUTION_MODES, EXECUTION_STATUS, FileStore, StepMachine as FlowEngine, LocalStorageStore, MemoryStore, StepMachine, TASK_STATUS, addDynamicTask, addNode, addProvides, addRequires, apply, applyAll, applyEvent, applyInferences, applyStepResult, batch, buildInferencePrompt, checkCircuitBreaker, computeAvailableOutputs, computeStepInput, createCliAdapter, createDefaultTaskState, createStepMachine as createEngine, createHttpAdapter, createInitialExecutionState, createInitialState, createLiveGraph, createStepMachine, detectStuckState, disableNode, drainTokens, enableNode, exportGraphConfig, exportGraphConfigToFile, extractReturnData, flowToMermaid, getAllTasks, getCandidateTasks, getDownstream, getNode, getProvides, getRequires, getTask, getUnreachableNodes, getUnreachableTokens, getUpstream, graphToMermaid, hasTask, inferAndApply, inferCompletions, injectTokens, inspect, isExecutionComplete, isNonActiveTask, isRepeatableTask, isTaskCompleted, isTaskRunning, loadGraphConfig, loadStepFlow, next, planExecution, removeNode, removeProvides, removeRequires, resetNode, resolveConfigTemplates, resolveVariables, restore, schedule, snapshot, validateGraph, validateGraphConfig, validateStepFlowConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map